Save work in progress

cairo_programs/signed_div_rem.cairo

@@ -0,0 +1,50 @@
+%builtins output range_check
+from starkware.cairo.common.math import signed_div_rem, assert_le
+from starkware.cairo.common.serialize import serialize_word
+
+func signed_div_rem_man{range_check_ptr}(value, div, bound) -> (q: felt, r: felt) {
+    let r = [range_check_ptr];
+    let biased_q = [range_check_ptr + 1];  // == q + bound.
+    let range_check_ptr = range_check_ptr + 2;
+    %{
+        from starkware.cairo.common.math_utils import as_int, assert_integer
+
+        assert_integer(ids.div)
+        assert 0 < ids.div <= PRIME // range_check_builtin.bound, \
+            f'div={hex(ids.div)} is out of the valid range.'
+
+        assert_integer(ids.bound)
+        assert ids.bound <= range_check_builtin.bound // 2, \
+            f'bound={hex(ids.bound)} is out of the valid range.'
+
+        int_value = as_int(ids.value, PRIME)
+        q, ids.r = divmod(int_value, ids.div)
+
+        assert -ids.bound <= q < ids.bound, \
+            f'{int_value} / {ids.div} = {q} is out of the range [{-ids.bound}, {ids.bound}).'
+
+        ids.biased_q = q + ids.bound
+    %}
+    let q = biased_q - bound;
+    assert value = q * div + r;
+    assert_le(r, div - 1);
+    assert_le(biased_q, 2 * bound - 1);
+    return (q, r);
+}
+
+func main{output_ptr: felt*, range_check_ptr: felt}() {
+    let (q_negative_expected, r_negative_expected) = signed_div_rem(-10, 3, 29);
+    let (q_negative, r_negative) = signed_div_rem_man(-10, 3, 29);
+    assert q_negative_expected = q_negative;
+    assert r_negative_expected = r_negative;
+    serialize_word(q_negative_expected);
+    serialize_word(q_negative);
+    serialize_word(r_negative_expected);
+    serialize_word(r_negative);
+
+    let (q_expected, r_expected) = signed_div_rem(10, 3, 29);
+    let (q, r) = signed_div_rem_man(10, 3, 29);
+    assert q_expected = q;
+    assert r_expected = r;
+    return ();
+}

cairo_programs/unsigned_div_rem.cairo

@@ -0,0 +1,27 @@
+%builtins range_check
+from starkware.cairo.common.math import unsigned_div_rem
+
+func unsigned_div_rem_man{range_check_ptr}(value, div) -> (q: felt, r: felt) {
+    let r = [range_check_ptr];
+    let q = [range_check_ptr + 1];
+    let range_check_ptr = range_check_ptr + 2;
+    %{
+        from starkware.cairo.common.math_utils import assert_integer
+        assert_integer(ids.div)
+        assert 0 < ids.div <= PRIME // range_check_builtin.bound, \
+            f'div={hex(ids.div)} is out of the valid range.'
+        ids.q, ids.r = divmod(ids.value, ids.div)
+    %}
+
+    return (q, r);
+}
+
+func main{range_check_ptr: felt}() {
+    let (q, r) = unsigned_div_rem_man(10, 3);
+    let (expected_q, expected_r) = unsigned_div_rem(10, 3);
+    assert q = expected_q;
+    assert r = expected_r;
+    assert q = 3;
+    assert r = 1;
+    return ();
+}

pkg/hints/math_hints.go

@@ -1,6 +1,7 @@
 package hints
 
 import (
+	"fmt"
 	"math/big"
 
 	"github.com/lambdaclass/cairo-vm.go/pkg/builtins"
@@ -68,38 +69,6 @@ func assert_not_zero(ids IdsManager, vm *VirtualMachine) error {
 	return nil
 }
 
-// Implements hint:from starkware.cairo.common.math.cairo
-//
-//	%{
-//		from starkware.crypto.signature.signature import FIELD_PRIME
-//		from starkware.python.math_utils import div_mod, is_quad_residue, sqrt
-//
-//		x = ids.x
-//		if is_quad_residue(x, FIELD_PRIME):
-//		    ids.y = sqrt(x, FIELD_PRIME)
-//		else:
-//		    ids.y = sqrt(div_mod(x, 3, FIELD_PRIME), FIELD_PRIME)
-//
-// %}
-func is_quad_residue(ids IdsManager, vm *VirtualMachine) error {
-	x, err := ids.GetFelt("x", vm)
-	if err != nil {
-		return err
-	}
-	if x.IsZero() || x.IsOne() {
-		ids.Insert("y", NewMaybeRelocatableFelt(x), vm)
-
-	} else if x.Pow(SignedFeltMaxValue()) == FeltOne() {
-		num := x.Sqrt()
-		ids.Insert("y", NewMaybeRelocatableFelt(num), vm)
-
-	} else {
-		num := (x.Div(lambdaworks.FeltFromUint64(3))).Sqrt()
-		ids.Insert("y", NewMaybeRelocatableFelt(num), vm)
-	}
-	return nil
-}
-
 func assert_not_equal(ids IdsManager, vm *VirtualMachine) error {
 	// Extract Ids Variables
 	a, err := ids.Get("a", vm)
@@ -180,12 +149,15 @@ func unsignedDivRem(ids IdsManager, vm *VirtualMachine) error {
 		return err
 	}
 
-	limit := new(big.Int).Div(lambdaworks.Prime(), rcBound.ToBigInt())
+	if rcBound.Cmp(lambdaworks.FeltZero()) == 0 {
+		return errors.New("range check bound cannot be zero")
+	}
+	primeBoundDivision := new(big.Int).Div(lambdaworks.Prime(), rcBound.ToBigInt())
 
 	// Check if `div` is greater than `limit`
-	cmp := div.ToBigInt().Cmp(limit) == 1
+	divGreater := div.ToBigInt().Cmp(primeBoundDivision) == 1
 
-	if div.IsZero() || cmp {
+	if div.IsZero() || divGreater {
 		return errors.Errorf("Div out of range: 0 < %d <= %d", div, rcBound)
 	}
 
@@ -220,50 +192,51 @@ Implements hint:
     %}
 */
 
-// func signedDivRem(ids IdsManager, vm *VirtualMachine) error {
-// 	div, err := ids.GetFelt("div", vm)
-// 	if err != nil {
-// 		return err
-// 	}
-// 	value, err := ids.GetFelt("value", vm)
-// 	if err != nil {
-// 		return err
-// 	}
-// 	bound, err := ids.GetFelt("bound", vm)
-// 	if err != nil {
-// 		return err
-// 	}
-
-// 	// It is safe to cast INNER_RC_BOUND into int64 since the constant is set to 65536
-// 	rcBound, err := vm.GetRangeCheckBound()
-// 	if err != nil {
-// 		return err
-// 	}
-
-// 	if rcBound.Cmp(lambdaworks.FeltZero()) == 0 {
-// 		return errors.New("range check bound cannot be zero")
-// 	}
-// 	primeBoundDivision := new(big.Int).Div(lambdaworks.Prime(), rcBound.ToBigInt())
-
-// 	// Check if `div` is greater than `limit` and make assertions
-// 	divGreater := div.ToBigInt().Cmp(primeBoundDivision) == 1
-// 	if div.IsZero() || divGreater {
-// 		return errors.Errorf("div=%d is out of the valid range", div)
-// 	}
-
-// 	if bound.Cmp(rcBound.Shr(1)) == 1 {
-// 		return errors.Errorf("bound=%d is out of the valid range")
-// 	}
-
-// 	sgnValue := value.ToSigned()
-// 	sgnBound := bound.ToBigInt()
-// 	intDiv := div.ToBigInt()
-
-// 	q := new(big.Int).Div(sgnValue, intDiv)
-// 	r := new(big.Int).Rem(sgnValue, intDiv)
-
-// 	return nil
-// }
+func signedDivRem(ids IdsManager, vm *VirtualMachine) error {
+	div, err := ids.GetFelt("div", vm)
+	if err != nil {
+		return err
+	}
+	value, err := ids.GetFelt("value", vm)
+	if err != nil {
+		return err
+	}
+	bound, err := ids.GetFelt("bound", vm)
+	if err != nil {
+		return err
+	}
+
+	rcBound, err := vm.GetRangeCheckBound()
+	if err != nil {
+		return err
+	}
+
+	if rcBound.Cmp(lambdaworks.FeltZero()) == 0 {
+		return errors.New("range check bound cannot be zero")
+	}
+	primeBoundDivision := new(big.Int).Div(lambdaworks.Prime(), rcBound.ToBigInt())
+
+	// Check if `div` is greater than `limit` and make assertions
+	divGreater := div.ToBigInt().Cmp(primeBoundDivision) == 1
+	if div.IsZero() || divGreater {
+		return errors.Errorf("div=%d is out of the valid range", div)
+	}
+
+	if bound.Cmp(rcBound.Shr(1)) == 1 {
+		return errors.Errorf("bound=%d is out of the valid range")
+	}
+
+	sgnValue := value.ToSigned()
+	sgnBound := bound.ToBigInt()
+	intDiv := div.ToBigInt()
+
+	q := new(big.Int).Div(sgnValue, intDiv)
+	r := new(big.Int).Rem(sgnValue, intDiv)
+
+	fmt.Println(sgnBound, q, r)
+
+	return nil
+}
 
 // pub fn signed_div_rem(
 //     vm: &mut VirtualMachine,

pkg/vm/cairo_run/cairo_run_test.go

@@ -202,3 +202,11 @@ func TestSqrtHint(t *testing.T) {
 		t.Errorf("Program execution failed with error: %s", err)
 	}
 }
+
+func TestUnsignedDivRemHint(t *testing.T) {
+	cairoRunConfig := cairo_run.CairoRunConfig{DisableTracePadding: false, Layout: "all_cairo", ProofMode: false}
+	_, err := cairo_run.CairoRun("../../../cairo_programs/sqrt.json", cairoRunConfig)
+	if err != nil {
+		t.Errorf("Program execution failed with error: %s", err)
+	}
+}