no more bitwise violations. also whitespace begone

Author: zfogg

.github/workflows/ci.yml

@@ -133,13 +133,23 @@ jobs:
         echo "Checking for bitwise operators (forbidden by educational constraints):"
 
         # Check for actual bitwise operators (the ones we want to avoid)
-        # Exclude && and || (logical ops) by using negative lookbehind/ahead
-        BITWISE_COUNT=$(grep -rn -E '(\&[^&]|\|[^|]|\^|<<|>>|~)' src/ | grep -v '//' | grep -v 'math.h.*\^' | grep -v '&&' | grep -v '||' | wc -l)
+        # Use sed to strip all comments before checking
+        BITWISE_VIOLATIONS=$(find src/ -name "*.c" -o -name "*.h" | xargs sed -e 's|//.*||g' -e 's|/\*.*\*/||g' | grep -n -E '(\&[^&]|\|[^|]|\^|<<|>>|~)' | grep -v '&&' | grep -v '||' || true)
+        
+        BITWISE_COUNT=$(echo "$BITWISE_VIOLATIONS" | grep -c . 2>/dev/null || true)
+        if [ -z "$BITWISE_COUNT" ] || [ "$BITWISE_COUNT" = "" ]; then
+          BITWISE_COUNT=0
+        fi
+        
         if [ "$BITWISE_COUNT" -eq 0 ]; then
           echo "✅ No bitwise operators found - constraint maintained!"
         else
-          echo "❌ Found $BITWISE_COUNT bitwise operations - review needed:"
-          grep -rn -E '(\&[^&]|\|[^|]|\^|<<|>>|~)' src/ | grep -v '//' | grep -v 'math.h.*\^' | grep -v '&&' | grep -v '||' | head -5
+          echo "❌ Found $BITWISE_COUNT bitwise operations - CONSTRAINT VIOLATION!"
+          echo "These violate the educational constraints:"
+          echo "$BITWISE_VIOLATIONS" | head -10
+          echo ""
+          echo "FAILING BUILD due to constraint violations"
+          exit 1
         fi
 
         echo ""

.github/workflows/security.yml

@@ -118,11 +118,19 @@ jobs:
 
         # Check for bitwise operators (should be forbidden by project rules)
         echo "### Bitwise operators:"
-        if grep -rn -E "(\&[^&]|\|[^|]|\^|<<|>>|~)" src/ | grep -v "//" | head -10; then
-          echo "❌ Found bitwise operators - may violate project constraints"
-          echo "Review: Are these compliant with the educational constraints?"
+        BITWISE_VIOLATIONS=$(find src/ -name "*.c" -o -name "*.h" | xargs sed -e 's|//.*||g' -e 's|/\*.*\*/||g' | grep -n -E '(\&[^&]|\|[^|]|\^|<<|>>|~)' | grep -v '&&' | grep -v '||' || true)
+        
+        BITWISE_COUNT=$(echo "$BITWISE_VIOLATIONS" | grep -c . 2>/dev/null || true)
+        if [ -z "$BITWISE_COUNT" ] || [ "$BITWISE_COUNT" = "" ]; then
+          BITWISE_COUNT=0
+        fi
+        
+        if [ "$BITWISE_COUNT" -eq 0 ]; then
+          echo "✅ No bitwise operators found - constraint maintained!"
         else
-          echo "✅ No bitwise operators found"
+          echo "❌ Found $BITWISE_COUNT bitwise operations - SECURITY RISK!"
+          echo "These may violate educational constraints and pose security risks:"
+          echo "$BITWISE_VIOLATIONS" | head -10
         fi
 
         # Check for arithmetic operators beyond basic ones

src/math.c

@@ -7,11 +7,11 @@
 bin binAdd(const bin x, const bin y) {
     bin r = binZERO;
     bin_int_t carry = 0;
-    
+
     for (bin_int_t i = 0; i < BIN_BITS; i++) {
         bin_int_t sum = x.bits[i] + y.bits[i] + carry;
-        r.bits[i] = sum & 1;  // Extract least significant bit
-        carry = sum >> 1;     // Extract carry bit
+        r.bits[i] = sum % 2;  // Extract least significant bit (check if odd)
+        carry = sum / 2;      // Extract carry bit (divide by 2)
     }
 
     // Check for overflow
@@ -112,18 +112,18 @@ bin binModulus(const bin x, const bin y) {
 
     if (binLT(x, y))
         return x;
-    
+
     // Use the same algorithm as division but return remainder instead
     bin remainder = binZERO;
-    
+
     for (int i = BIN_BITS-1; i >= 0; --i) {
         remainder = binShiftL1(remainder);
         remainder.bits[0] = x.bits[i];
-        
+
         if (binGTEQ(remainder, y))
             remainder = binSubtract(remainder, y);
     }
-    
+
     return remainder;
 }
 
@@ -134,7 +134,7 @@ bin binPow(const bin x, const bin y) {
         return binONE;
     else if (binEQOne(y))
         return x;
-    
+
     // Use binary exponentiation (square and multiply)
     bin result = binONE;
     bin base = x;
@@ -146,7 +146,7 @@ bin binPow(const bin x, const bin y) {
         base = binMultiply(base, base);
         exponent = binShiftR1(exponent);
     }
-    
+
     return result;
 }
 
@@ -156,39 +156,39 @@ bin binSqrt(const bin x) {
         return binZERO;
     else if (binEQOne(x))
         return binONE;
-    
+
     // Use Newton-Raphson method: x_{n+1} = (x_n + a/x_n) / 2
     // Start with x/2 as initial guess
     bin guess = binShiftR1(x);
     bin prev_guess;
     bin_int_t iterations = 0;
     const bin_int_t max_iterations = 30; // Prevent infinite loops
-    
+
     do {
         prev_guess = guess;
-        
+
         // Calculate a/guess
         bin quotient = binDivide(x, guess);
-        
+
         // Calculate (guess + a/guess) / 2
         bin sum = binAdd(guess, quotient);
         guess = binShiftR1(sum);
-        
+
         iterations++;
-        
+
         // Stop if we've converged or hit max iterations
     } while (!binEQ(guess, prev_guess) && iterations < max_iterations);
-    
+
     return guess;
 }
 
 // Calculate the base2 logarithm of a binary number
 bin binLog2(const bin x) {
     assert(!binEQZero(x)); // log2(0) is undefined
-    
+
     if (binEQOne(x))
         return binZERO; // log2(1) = 0
-    
+
     // Find the position of the most significant bit (MSB)
     // This gives us the integer part of log2(x)
     return binMSBi(x);
@@ -198,24 +198,24 @@ bin binLog2(const bin x) {
 // Calculate the base10 logarithm of a binary number
 bin binLog10(const bin x) {
     assert(!binEQZero(x)); // log10(0) is undefined
-    
+
     if (binEQOne(x))
         return binZERO; // log10(1) = 0
-    
+
     // Use a lookup table approach for common values
     // For values 1-1000, we can pre-calculate log10
     if (binLTEQ(x, binNew(1000))) {
         // Simple lookup table for powers of 10 and common values
         if (binEQ(x, binNew(10))) return binNew(1);
         if (binEQ(x, binNew(100))) return binNew(2);
         if (binEQ(x, binNew(1000))) return binNew(3);
-        
+
         // For other values, find the largest power of 10 that fits
         if (binGTEQ(x, binNew(100))) return binNew(2);
         if (binGTEQ(x, binNew(10))) return binNew(1);
         return binZERO; // x < 10
     }
-    
+
     // For larger values, use a different approach
     // Count the number of digits in base 10 representation
     bin temp = x;
@@ -224,7 +224,7 @@ bin binLog10(const bin x) {
         temp = binDivide(temp, binNew(10));
         digit_count++;
     }
-    
+
     // log10(x) is approximately (number of digits - 1)
     return binNew(digit_count - 1);
 }
@@ -234,17 +234,17 @@ bin binLog10(const bin x) {
 // This is a simplified integer-based approach that maintains the constraint-based design
 bin binLog(const bin x) {
     assert(!binEQZero(x)); // log(0) is undefined
-    
+
     if (binEQOne(x))
         return binZERO; // log(1) = 0
-    
+
     // For integer natural logarithm, we use a simple approximation:
     // ln(x) ≈ ln(2) * log2(x) where ln(2) ≈ 0.693
     // Since we're working with integers, we'll use a scaled approach
-    
+
     // Get the log2 value (MSB position)
     bin log2_val = binLog2(x);
-    
+
     // Simple lookup table approach for small values (more accurate)
     if (binLTEQ(x, binNew(16))) {
         // Pre-calculated ln(x) values scaled by 1 (rounded to nearest integer)
@@ -256,15 +256,15 @@ bin binLog(const bin x) {
         else if (x_int <= 12) return binNew(2);
         else return binNew(3);
     }
-    
+
     // For larger values, use the approximation ln(x) ≈ 0.7 * log2(x)
     // We'll use integer arithmetic: ln(x) ≈ (7 * log2(x)) / 10
     // But since we need integer results, we'll round: ln(x) ≈ (7 * log2(x) + 5) / 10
-    
+
     bin seven = binNew(7);
     bin ten = binNew(10);
     bin five = binNew(5);
-    
+
     // Calculate (7 * log2_val + 5) / 10
     bin scaled = binAdd(binMultiply(seven, log2_val), five);
     return binDivide(scaled, ten);

src/math.h

@@ -4,14 +4,14 @@
 
 /**
  * @brief Add two binary numbers
- * 
+ *
  * Performs binary addition of two binary numbers. The function handles
  * binary arithmetic with proper carry propagation.
- * 
+ *
  * @param x The first binary number (addend)
  * @param y The second binary number (addend)
  * @return The sum of x and y as a binary number
- * 
+ *
  * @note This function performs standard binary addition with carry handling.
  *       The result is a binary number representing the arithmetic sum.
  */
@@ -21,22 +21,22 @@ bin binAdd(const bin x, const bin y);
  * @brief Increment a binary number by one
  * @param x The binary number to increment
  * @return The incremented binary number (x + 1)
- * 
+ *
  * @note Don't try to increment the maximum binary number value.
  *       Currently this won't crash but it should.
  */
 bin binIncrement(const bin x);
 
 /**
  * @brief Subtract two binary numbers
- * 
+ *
  * Performs binary subtraction of y from x. The function handles
  * binary arithmetic with proper borrow propagation.
- * 
+ *
  * @param x The binary number to subtract from (minuend)
  * @param y The binary number to subtract (subtrahend)
  * @return The difference of x and y as a binary number (x - y)
- * 
+ *
  * @note This function performs standard binary subtraction with borrow handling.
  *       If y > x, the result will be the two's complement representation.
  */
@@ -46,17 +46,17 @@ bin binSubtract(const bin x, const bin y);
  * @brief Decrement a binary number by one
  * @param x The binary number to decrement
  * @return The decremented binary number (x - 1)
- * 
+ *
  * @note Don't try to decrement the minimum binary number value (0).
  */
 bin binDecrement(const bin x);
 
 /**
  * @brief Multiply two binary numbers
- * 
+ *
  * Performs binary multiplication of two binary numbers using
  * the standard recursive multiplication algorithm.
- * 
+ *
  * @param x The first binary number (multiplicand)
  * @param y The second binary number (multiplier)
  * @return The product of x and y as a binary number
@@ -65,42 +65,42 @@ bin binMultiply(const bin x, const bin y);
 
 /**
  * @brief Divide two binary numbers
- * 
+ *
  * Performs binary division of x by y using the standard
  * long division algorithm.
- * 
+ *
  * @param x The binary number to divide (dividend)
  * @param y The binary number to divide by (divisor)
  * @return The quotient of x divided by y as a binary number
- * 
+ *
  * @note This function assert()s that the divisor is not zero.
  */
 bin binDivide(const bin x, const bin y);
 
 /**
  * @brief Calculate the remainder of division
- * 
+ *
  * Performs binary division and returns the remainder
  * (modulo operation).
- * 
+ *
  * @param x The binary number to divide (dividend)
  * @param y The binary number to divide by (divisor)
  * @return The remainder of x divided by y as a binary number
- * 
+ *
  * @note This function assert()s that the divisor is not zero.
- *       
+ *
  */
 bin binModulus(const bin x, const bin y);
 
 /**
  * @brief Raise a binary number to a power
- * 
+ *
  * Calculates x raised to the power of y (x^y).
- * 
+ *
  * @param x The base binary number
  * @param y The exponent binary number
  * @return x raised to the power of y as a binary number
- * 
+ *
  * @note This function implements binary exponentiation.
  *       For y = 0, the result is 1.
  *       For y = 1, the result is x.
@@ -112,7 +112,7 @@ bin binPow(const bin x, const bin y);
  * @brief Calculate the square root of a binary number
  * @param x The binary number to calculate the square root of
  * @return The square root of x as a binary number
- * 
+ *
  * @note This function implements the Newton-Raphson method for square root calculation.
  */
 bin binSqrt(const bin x);