forked from lambdaclass/cairo-vm
-
Notifications
You must be signed in to change notification settings - Fork 1
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
feat(hints): add NewHint#47 (lambdaclass#1030)
* Refactor some cairo_programs as library - uint384 - uint384_extension I need this changes for later tests * Refactor pack and split, macro hygiene Pack and split were unified into a generic function in `uint_utils.rs`. UintNNN specific functions were changed to `uNNN_pack` and `uNNN_split`, that internally use the generic ones. Some macros were using items without specifying full path, and I fixed this. With this change a lot of imports weren't needed anymore, and so were removed to appease clippy. Also add the groundwork for the new hint to be implemented. * Add NewHint#47 * Update changelog * Add stdlib prelude import * Import HashMap from stdlib * Fix contracts * Fix wasm-tests * Change bitmask to `u128::MAX` * Revert "Change bitmask to `u128::MAX`" This reverts commit 7a1bea7. * Compare memory_holes with correct amount * Rename uint512 -> fq, fq -> fq_test; Add comment * Fix contract compilation errors * Fix compilation error * Fix cairo_run_fq test * Move changelog entry * Fix failing tests * Fix compilation errors * Fix test error Was using wrong pack function * Define empty mains on libraries * Use bare array instead of vec Co-authored-by: fmoletta <99273364+fmoletta@users.noreply.github.com> * Make pack and split methods instead of functions * Fix merge errors * Fix errors and add BigInt3::split86 * Make u512_pack and split functions into methods * Re-add disappeared newline inside hint * Fix compilation errors --------- Co-authored-by: fmoletta <99273364+fmoletta@users.noreply.github.com>
- Loading branch information
Showing
56 changed files
with
1,052 additions
and
548 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
21 changes: 11 additions & 10 deletions
21
cairo_programs/benchmarks/field_arithmetic_get_square_benchmark.cairo
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,195 @@ | ||
| from starkware.cairo.common.uint256 import Uint256, split_64 | ||
| from starkware.cairo.common.math_cmp import is_le | ||
|
|
||
| from cairo_programs.uint384_extension import Uint384, Uint768, u384 | ||
|
|
||
| struct Uint512 { | ||
| d0: felt, | ||
| d1: felt, | ||
| d2: felt, | ||
| d3: felt, | ||
| } | ||
|
|
||
| const SHIFT = 2 ** 128; | ||
| const ALL_ONES = 2 ** 128 - 1; | ||
| const HALF_SHIFT = 2 ** 64; | ||
|
|
||
| namespace u512 { | ||
| func add_u512_and_u256{range_check_ptr}(a: Uint512, b: Uint256) -> Uint512 { | ||
| alloc_locals; | ||
|
|
||
| let a_low = Uint256(low=a.d0, high=a.d1); | ||
| let a_high = Uint256(low=a.d2, high=a.d3); | ||
|
|
||
| let (sum_low, carry0) = add_carry(a_low, b); | ||
|
|
||
| local res: Uint512; | ||
|
|
||
| res.d0 = sum_low.low; | ||
| res.d1 = sum_low.high; | ||
| // res.d2 = sum_low.d2; | ||
|
|
||
| // TODO : create add_one (high bits not needed) | ||
| let a_high_plus_carry = add(a_high, Uint256(carry0, 0)); | ||
|
|
||
| res.d2 = a_high_plus_carry.low; | ||
| res.d3 = a_high_plus_carry.high; | ||
|
|
||
| return res; | ||
| } | ||
|
|
||
| func mul_u512_by_u256{range_check_ptr}(a: Uint512, b: Uint256) -> Uint768 { | ||
| alloc_locals; | ||
| let (a0, a1) = split_64(a.d0); | ||
| let (a2, a3) = split_64(a.d1); | ||
| let (a4, a5) = split_64(a.d2); | ||
| let (a6, a7) = split_64(a.d3); | ||
|
|
||
| let (b0, b1) = split_64(b.low); | ||
| let (b2, b3) = split_64(b.high); | ||
|
|
||
| local B0 = b0 * HALF_SHIFT; | ||
| local b12 = b1 + b2 * HALF_SHIFT; | ||
|
|
||
| let (res0, carry) = u384.split_128(a1 * B0 + a0 * b.low); | ||
| let (res2, carry) = u384.split_128(a3 * B0 + a2 * b.low + a1 * b12 + a0 * b.high + carry); | ||
| let (res4, carry) = u384.split_128( | ||
| a5 * B0 + a4 * b.low + a3 * b12 + a2 * b.high + a1 * b3 + carry | ||
| ); | ||
| let (res6, carry) = u384.split_128( | ||
| a7 * B0 + a6 * b.low + a5 * b12 + a4 * b.high + a3 * b3 + carry | ||
| ); | ||
| let (res8, carry) = u384.split_128(a7 * b12 + a6 * b.high + a5 * b3 + carry); | ||
| let (res10, carry) = u384.split_128(a7 * b3 + carry); | ||
| let res = Uint768(d0=res0, d1=res2, d2=res4, d3=res6, d4=res8, d5=res10); | ||
| return res; | ||
| } | ||
|
|
||
| func u512_unsigned_div_rem{range_check_ptr}(x: Uint512, div: Uint256) -> ( | ||
| q: Uint512, r: Uint256 | ||
| ) { | ||
| alloc_locals; | ||
| local quotient: Uint512; | ||
| local remainder: Uint256; | ||
|
|
||
| %{ | ||
| def split(num: int, num_bits_shift: int, length: int): | ||
| a = [] | ||
| for _ in range(length): | ||
| a.append( num & ((1 << num_bits_shift) - 1) ) | ||
| num = num >> num_bits_shift | ||
| return tuple(a) | ||
|
|
||
| def pack(z, num_bits_shift: int) -> int: | ||
| limbs = (z.low, z.high) | ||
| return sum(limb << (num_bits_shift * i) for i, limb in enumerate(limbs)) | ||
|
|
||
| def pack_extended(z, num_bits_shift: int) -> int: | ||
| limbs = (z.d0, z.d1, z.d2, z.d3) | ||
| return sum(limb << (num_bits_shift * i) for i, limb in enumerate(limbs)) | ||
|
|
||
| x = pack_extended(ids.x, num_bits_shift = 128) | ||
| div = pack(ids.div, num_bits_shift = 128) | ||
|
|
||
| quotient, remainder = divmod(x, div) | ||
|
|
||
| quotient_split = split(quotient, num_bits_shift=128, length=4) | ||
|
|
||
| ids.quotient.d0 = quotient_split[0] | ||
| ids.quotient.d1 = quotient_split[1] | ||
| ids.quotient.d2 = quotient_split[2] | ||
| ids.quotient.d3 = quotient_split[3] | ||
|
|
||
| remainder_split = split(remainder, num_bits_shift=128, length=2) | ||
| ids.remainder.low = remainder_split[0] | ||
| ids.remainder.high = remainder_split[1] | ||
| %} | ||
|
|
||
| let res_mul: Uint768 = mul_u512_by_u256(quotient, div); | ||
|
|
||
| assert res_mul.d4 = 0; | ||
| assert res_mul.d5 = 0; | ||
|
|
||
| let check_val: Uint512 = add_u512_and_u256( | ||
| Uint512(res_mul.d0, res_mul.d1, res_mul.d2, res_mul.d3), remainder | ||
| ); | ||
|
|
||
| // assert add_carry = 0; | ||
| assert check_val = x; | ||
|
|
||
| let is_valid = lt(remainder, div); | ||
| assert is_valid = 1; | ||
|
|
||
| return (quotient, remainder); | ||
| } | ||
|
|
||
| // Verifies that the given integer is valid. | ||
| func check{range_check_ptr}(a: Uint256) { | ||
| // tempvar h = a.high - 2 ** 127; | ||
| [range_check_ptr] = a.low; | ||
| [range_check_ptr + 1] = a.high; | ||
| let range_check_ptr = range_check_ptr + 2; | ||
| return (); | ||
| } | ||
|
|
||
| // Assume a and b are lower than 2**255-19 | ||
| func add{range_check_ptr}(a: Uint256, b: Uint256) -> Uint256 { | ||
| alloc_locals; | ||
| local res: Uint256; | ||
| local carry_low: felt; | ||
| // unused. added to use UINT256_ADD | ||
| local carry_high: felt; | ||
| // this hint is not implemented: | ||
| // %{ | ||
| // sum_low = ids.a.low + ids.b.low | ||
| // ids.carry_low = 1 if sum_low >= ids.SHIFT else 0 | ||
| // %} | ||
| %{ | ||
| sum_low = ids.a.low + ids.b.low | ||
| ids.carry_low = 1 if sum_low >= ids.SHIFT else 0 | ||
| sum_high = ids.a.high + ids.b.high + ids.carry_low | ||
| ids.carry_high = 1 if sum_high >= ids.SHIFT else 0 | ||
| %} | ||
| // changed hint, no carry_high | ||
| assert carry_low * carry_low = carry_low; | ||
|
|
||
| assert res.low = a.low + b.low - carry_low * SHIFT; | ||
| assert res.high = a.high + b.high + carry_low; | ||
| // check(res); | ||
|
|
||
| return res; | ||
| } | ||
|
|
||
| func add_carry{range_check_ptr}(a: Uint256, b: Uint256) -> (res: Uint256, carry: felt) { | ||
| alloc_locals; | ||
| local res: Uint256; | ||
| local carry_low: felt; | ||
| local carry_high: felt; | ||
| %{ | ||
| sum_low = ids.a.low + ids.b.low | ||
| ids.carry_low = 1 if sum_low >= ids.SHIFT else 0 | ||
| sum_high = ids.a.high + ids.b.high + ids.carry_low | ||
| ids.carry_high = 1 if sum_high >= ids.SHIFT else 0 | ||
| %} | ||
|
|
||
| assert carry_low * carry_low = carry_low; | ||
| assert carry_high * carry_high = carry_high; | ||
|
|
||
| assert res.low = a.low + b.low - carry_low * SHIFT; | ||
| assert res.high = a.high + b.high + carry_low - carry_high * SHIFT; | ||
| check(res); | ||
|
|
||
| return (res, carry_high); | ||
| } | ||
|
|
||
| func lt{range_check_ptr}(a: Uint256, b: Uint256) -> felt { | ||
| if (a.high == b.high) { | ||
| return is_le(a.low + 1, b.low); | ||
| } | ||
| return is_le(a.high + 1, b.high); | ||
| } | ||
| } | ||
|
|
||
| func main() { | ||
| return (); | ||
| } |
Oops, something went wrong.