Mathematical question

[ad1mt]

I'm working on functions for bitwise NOT, AND, OR, XOR in a big integer library.
I've implemented negative values with a boolean sign flag (not as twos-complement).
I'm thinking about how the boolean sign flag should be dealt with in these functions, and was wondering if there were any maths experts who had an opinion on this.
For example, is there a strict mathematical rule for calculating the value of

Code: Pascal  [Select][+][-]

1. ( (-1) AND (+1) )

My intuition says to attempt the same operation on the boolean sign flags of the operands. So in the example above with the AND function, the result would be negative if both operand1 AND operand2 were both negative, otherwise the result would be positive. But that might not be correct.
Another idea is to say these functions make no sense when the signs are different, and that an overflow exception should be raised.
I tried asking Google, but it just gave me answers for the arithmetic operators plus, minus, multiply, etc.

[AlexTP]

>For example, is there a strict mathematical rule for calculating the value of   ( (-1) AND (+1) )

no. there is no such rule.
because in math, AND (and others) are defined only for non-negative numbers, integer numbers >=0.

i studied math (in Ru institute) and math did not use negative numbers for AND OR etc.
operators were not defined for negative nums.

[Zvoni]

I'm working on functions for NOT, AND, OR, XOR in a big integer library.
I've implemented negative values with a boolean sign flag (not as twos-complement).
I'm thinking about how the boolean sign flag should be dealt with in these functions, and was wondering if there were any maths experts who had an opinion on this.
For example, is there a strict mathematical rule for calculating the value of

Code: Pascal  [Select][+][-]

1. ( (-1) AND (+1) )

My intuition says to attempt the same operation on the boolean sign flags of the operands. So in the example above with the AND function, the result would be negative if both operand1 AND operand2 were both negative, otherwise the result would be positive. But that might not be correct. I tried asking Google, but it just gave me answers for all the operators except AND.

Depends...
if it's a logical AND, your sample would return True (with whichever bitwise representation)
if it's a bitwise AND it would return positive 1, since it only compares the single bits, and returns 1 for the bit, where both bits are 1 in both operands

EDIT: Ahh...well.. i didn't study math, so i have to believe Alex...

[paule32]

The Precedence is:

- pow
- div
- mul
- add
- sub

Then: you could set your negative Numbers in abs() - the absolute value which is:

(| -1 | AND | +1 |).

which is than (I don't know your logic of your Application, so you have decide your self):

(1 AND 1).

which is:

TRUE & TRUE.

which results in TRUE.  or:  1 & 1 = 1.

[440bx]

I'm working on functions for NOT, AND, OR, XOR in a big integer library.

This implies that you're dealing with bitwise operations, not logical operations.

if you assign 1 to indicate a number is negative and 0 to indicate it is positive then the standard logic tables apply, i.e, 1 and 0 = 0 (or TRUE and FALSE = FALSE.)  It's just a bitwise operation, nothing special about it.

[ad1mt]

Depends...
if it's a logical AND, your sample would return True (with whichever bitwise representation)
if it's a bitwise AND it would return positive 1, since it only compares the single bits, and returns 1 for the bit, where both bits are 1 in both operands

It is bitwise operations I'm defining. I've edited my original post to make this clear. Logical operations would fail strict type checking.

[marcov]

Depends...
if it's a logical AND, your sample would return True (with whichever bitwise representation)

 I agree with AlexTP, primarily it is an unsigned operation.

So while what you say is true, the switch to the bitwise representation is like a signed->unsigned type conversion that on non 2-complement machines might change the bit pattern. Also there is the potential issue of sign extension before that happens if both operand sizes are mismatched.

I think Pascal's sibling Modula2 wouldn't let you do it, since there those operations are only allowed for CARDINAL, and there are no implicit conversions between signed and unsigned.

[paule32]

@440bx

not exactly.
You don't need bitwise, it is bitwise.

Code: Pascal  [Select][+][-]

1. var A: Byte; B: Byte;
2. begin
3.   A := -1;
4.   B :=  1;
5.   if (A) AND (B) then  // -1 AND 1  =>  FALSE & TRUE  =>  FALSE.
6. end.

[ad1mt]

Doing a bitwise operation on the boolean sign flag is definitely wrong in my opinion, because that breaks strict type checking rules.
From what Alex says, it appears to me that these operations make no sense with negative values.
So unless I hear differently, I think I will perform the operation on the unsigned (absolute) values, and raise an exception if any of the operands are negative.
The calling code can then choose to use the result and ignore the exception.

[AlexTP]

So unless I hear differently, I think I will perform the operation on the unsigned (absolute) values, and raise an exception if any of the operands are negative.
The calling code can then choose to use the result and ignore the exception.

It is reasonable choice.
exception for negative numbers for bit operators.

[paule32]

You don't need strict Exception Faults.
You can (as I don't know your Application logic) set ALL Values to ABS() - the absolute Value.
Since in mathematically Set's of natural Numbers IN consists only positive Digits (0 ... 9), the POV (Point Of View) are the positive mathematically Object's.

[Fibonacci]

Imho there is no negative value if it comes to bitwise operations. You are doing operations on bits. Minus sign is a bit in some numeric types. When doing and/or/xor, this is just a bit, not a sign, it doesnt matter.

4 byte "-1" is just FFFFFFFF (decimal 4294967295). You cant know if its negative value if you dont know how to treat this number, as signed or not.

Your "-1" is 32 "1" bits. Then you do "and 1", the result of this operation is 1.

[paule32]

@Fibonacci

right.
It depends on the Application Logic.
You know: Input Angle is Output Angle...

POV on natural Numbers Body ( IN ) or the partial Sum of the real Numbers Body ( IR ) are the positive Numbers (0 .. 9) without floats.

for ALL other cases (Bits) -1 Bit is 0 (see: Buffer overflow => 11 => 000).

XOR is used to set Registers/Values to 0.

Code: Pascal  [Select][+][-]

1. Like:  xor rax, rax  ; which set's rax to 0

[Zvoni]

4 byte "-1" is just FFFFFFFF (decimal 4294967295).

How do you figure that?
TS wrote "... not as two-complements"

FFFFFFFF being "-1" is only for "two-complements" (as far as i understand stuff like that)

[paule32]

@Zvoni

0xFFFFFFFE  =>  2 ^32 - 1  =>  2 ^31  =>  (positive Numbers: 0 .. 2 ^31)
0xFFFFFFFF  =>  2 ^32   => (negative Number Flag, where -1 is the Sign-Bit)