bitvector | Static bit vector structures in Go

The paper to read regarding these operations is https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/z3prefix.pdf

Note that the operations are "reversed." Z3_mk_bvsub_no_overflow will be true if there is no overflow. And similarly for underflow. This double-negation is unfortunate, but that's how the operations are defined.

How these relate to the CPU's OV/CY flags is an interesting question. I think it's best to consider the results of z3 (as explained in the above paper) as mathematical semantics. In z3 parlance, overflow exists when the infinitely precise result lies to the right of the range-covered by the bit-vector size, and underflow exists when it lies to the left.

Your particular architecture (x86 most likely, but not necessarily!), however, might have different rules on how these flags are produced. In particular CPU's do not care (or know) whether the arguments are signed or unsigned. The magic of 2's complement arithmetic allows them to treat the arguments uniformly, and thus there's no direct correspondence with the typed-analysis z3 performs. Here is the description from the x86 manual:

The SUB instruction does not distinguish between signed or unsigned operands. Instead, the processor evaluates the result for both data types and sets the OF and CF flags to indicate a borrow in the signed or unsigned result, respectively. The SF flag indicates the sign of the signed result.

Long story short, you'll have to be very specific about whether you're doing signed/unsigned arithmetic, and look at the precise x86 (or whatever architecture you're on, but I presume they must all be similar), and see what the actual correspondence might be. Keep in mind that the correspondence may not be precise. For legacy/historical reasons, x86 does things in its own idiosyncratic ways, which may not perfectly match the mathematical results that z3 produces based on the above paper.

The best way would be to extract the top and bottom parts, and splice the replacement directly inside. Like this:

Two problems:

1. You are mixing ByRow with normal transform which is by column
2. You can't mutate type of puntaje column

You probably want to do this:

Please always post reproducible code segments. Just posting "parts" of your code makes it very difficult for others to diagnose the problem.

Having said that, your problem is that the value 0-10 does not fit in an int64 value as a bit-vector. Here's a minimal reproducer:

if, else only accepts a boolean. So I guess you need to call all or any on the BitVector first?

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.