bitvector | official repo for the paper A General Framework | Machine Learning library

It seems you have statistics auto gathering enabled:

Don't use unique! for this, because that mutates the fh_5.symbol column. In other words, unique! removes the duplicate values from that column, which will change the length of that column. Use unique instead. So, something like this:

Slice types like &str or &[u8] are fat pointers, containing a pointer to some data and a length. The type &[T] is syntactic sugar for a struct resembling this:

EXC_BAD_ACCESS happens when you try to access memory which isn't allocated by the application; which the application has no access privilege to.
I suppose the error is because your not adding nodes to your tree. Your just calling them. And over here: if (t==NULL), t->b.get_bitvector()->at(g) is called only if the node address is 0x0, hence the error.

What you should do is, make the logic to add a node if not found in some way and change t==NULL to t!=NULL.

Note: Try using nullptr and ditch NULL when working with pointers.

When I run your program with Bits = 4096, it does not say unknown. It simply does not finish quickly (I waited for a few minutes), and I wouldn't expect it to.

Bitvector solver is complete. That is, if you wait long enough, it'll eventually return sat or unsat, assuming you do not run out of memory (and patience). For this problem, however, the amount you'll wait might be practically infinite, and you'll most likely run out of memory on your computer long before that happens. So, I'm not sure how you're getting that unknown. Maybe you're using some timeout options, or something else you're not showing here.

You can try adding constraints of the form: p_vec < n and q_vec < p_vec to break symmetries. And it could indeed help in some cases since n is a constant. But this is in general futile, and for any reasonable bit size for use in cryptographic practice, the solver will practically loop forever.

Factorization is a hard problem for obvious reasons and an SMT solver is definitely not the right tool for it. See here for an earlier discussion: Bitvector function Z3

I am not sure if there is any special bit logic function, see e.g. here.

But how about this?

You can use new_Hex() and to_Hex():

You can get DenseVector by (dv :== 6.0).toDeseVector.

I'm not sure about reasons of this asymmetry, I guess authors probably were more concerned about performance in case of DenseVector. See DenseVector source vs DenseMatrix source.

As no body answered my question, and I performed some tests and researches, I will answer it myself and I hope to be usable for others:

Which is The Most Efficient way to keep status flags for this situation?

Because the computer will align data in memory according to the processor architecture ,Even in C# (as a high level language), still It is generally a good advise to avoid separate boolean fields in classes.

• Using bit-mask based solutions (same as flags Enum or BitVector32 or manual bit-mask operations) is preferable. For two or more boolean values, it’s a better solution in memory-load and is fast. But when we have a single boolean state var, this is useless.

Generally we can say if we choose flags Enum or else BitVector32 as solution, it should be almost as fast as we expect for a manual bit-masked operations in C# in most cases.

• When we need to use various small numeric ranges in addition to boolean values as state, BitVector32 is helpful as an existing util that helps us to keep our states in one variable and saving memory-load.

• We may prefer to use flags Enum to make our code more maintainable and clear.

Also we can say about the 2'nd part of the question

Is it ( = the most efficient way) deeply depends on current in-using tools such as Compiler or even Runtime (CLR)?

Partially Yes. When we choose each one of mentioned solutions (rather than manual bitwise operations), the performance is depended on compiler optimization that will do (for example in method calls we made when we were using BitVector32 or Enum and or enum operations, etc). So optimizations will boost up our code, and it seems this is common in C#, but for every solution rather than manual bitwise operations, with tools rather than .net official, it is better to be tested in that case.