bitsets | Ordered subsets over a finite domain

After reading carefully I thought the reason could be signed characters. If signed characters are involved,

You need to call the constructor of std::bitset like:

Try:

You can convert to any base with this method, in your case this should work:

In Erlang, types are what are defined in here. Internal Erlang and C/C++ std representations do not match, you cannot return a, for example, int64_t from C and use it directly from Erlang.

Same for complex structures, is PrioryQueue an Erlang's list() or a {list(), pos_integer()}?

This means that you need to transform types back and forth, using the enif_get_* and enif_make_* erl_nif functions. For really complex structures this may be tedious, so you really need to consider if it wouldn't be enough using resource objects.

Resource objects are just pointers to memory, and thus, opaque for Erlang. You can have this opaque hold the pointer to the priority queue memory and include methods to put/2 and get/2 Erlang terms to the queue.

Why are the functions from erl_nif required?

Erlang has dynamic typing, where each reference held by a variable includes its type (either in the value for the immediate terms, or in the reference for the referenced terms), while C/C++ have static typing, where the variable is the one that states the type only at compile time.

For C/C++, 0xfabada could be an int, uint, a char*, a void* pointing to your custom structure...

Other reasons for the representations not to match include:

1. Erlang's integers have variable size
2. Erlang terms are tagged (some bits of the reference indicate the type)
3. The closest thing to an atom in C/C++ is an enum, and they are quite different
4. Binaries (both short an long binaries) and subbinaries
5. Memory management ... and so on.

After some back and forth on Barry's answer, I've come up with the following answer that merges the concepts and handles some empty-sequence edge cases (Full code):

We are allowed to pass a predicate to a function only if it is a constexpr lambda, as only literal types are allowed in constexpr functions, and normal free-floating functions aren't literal types (although I suppose you could wrap one within your lambda).

Our generic filter function will accept a sequence and a predicate, and return a new sequence. We will use constexpr if to handle empty sequence cases (which also requires the maybe_unused attribute on the predicate, because it's unused) :

As you can see from this table the operator ! has a higher precedence that & (Bitwise and, not address of), so your code should looks like this:

You could simply do

While z3 (or any SMT solver) can handle all of these, getting a nice sampling of satisfying assignments would be rather difficult to control. SMT solvers are optimized for just giving you a model, and they don't have much in terms of how you want to sample the solution space.

Incidentally, this is an active research area in SMT solving. Here's a paper that appeared only 6 weeks ago on this very topic: https://ieeexplore.ieee.org/document/8894251

So, I'd say if support for "good sampling" is your primary motivation, using an SMT solver is probably not the best choice. If your goal is to find satisfying assumptions for bit-vectors expressed conveniently (there are high level APIs in any language you can imagine these days), then z3 would be an extremely fine choice.

From your description, good sampling sounds like the primary motivation though, and for that SMT solvers are probably not that great. At least not for the time being.