#include <algorithm>
#include <chrono>
#include <thread>
#include <csignal>
#include "config.hpp"
#include "statistics.hpp"
#include "battery/utility.hpp"
#include "battery/allocator.hpp"
#include "battery/vector.hpp"
#include "battery/shared_ptr.hpp"
#include "lala/simplifier.hpp"
#include "lala/vstore.hpp"
#include "lala/cartesian_product.hpp"
#include "lala/interval.hpp"
#include "lala/pc.hpp"
#include "lala/terms.hpp"
#include "lala/fixpoint.hpp"
#include "lala/search_tree.hpp"
#include "lala/bab.hpp"
#include "lala/split_strategy.hpp"
#include "lala/interpretation.hpp"
#include "lala/flatzinc_parser.hpp"

Classes
struct	UniqueAlloc< Alloc, n >

struct	UniqueLightAlloc< Alloc, n >

struct	AbstractDomains< Universe, BasicAllocator, PropAllocator, StoreAllocator >

struct	AbstractDomains< Universe, BasicAllocator, PropAllocator, StoreAllocator >::tag_copy_cons

struct	AbstractDomains< Universe, BasicAllocator, PropAllocator, StoreAllocator >::tag_gpu_block_copy

Typedefs
using	Itv = Interval<local::ZLB>

template<class Universe >
using	CP

Functions
void	block_signal_ctrlc ()

bool	must_quit ()

template<class A , class Timepoint >
bool	check_timeout (A &a, const Timepoint &start)

Typedef Documentation

◆ Itv

using Itv = Interval<local::ZLB>

◆ CP

template<class Universe >

using CP

Initial value:

 AbstractDomains<Universe,
  battery::statistics_allocator<battery::standard_allocator>,
  battery::statistics_allocator<UniqueLightAlloc<battery::standard_allocator, 0>>,
  battery::statistics_allocator<UniqueLightAlloc<battery::standard_allocator, 1>>>

Function Documentation

◆ block_signal_ctrlc()

void block_signal_ctrlc ( )

◆ must_quit()

bool must_quit ( )

◆ check_timeout()

template<class A , class Timepoint >

bool check_timeout	(	A &	a,
		const Timepoint &	start )

Check if the timeout of the current execution is exceeded and returns false otherwise. It also update the statistics relevant to the solving duration and the exhaustive flag if we reach the timeout.

Classes

Typedefs