Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

chore: simplify algorithms::mul* #382

Merged
merged 3 commits into from
Jun 15, 2024
Merged

chore: simplify algorithms::mul* #382

Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
4b4436e
chore: simplify algorithms::mul*
DaniPopes Jun 15, 2024
6e25d56
Merge branch 'main' into simplify-muls
prestwich Jun 15, 2024
bd78b72
Merge branch 'main' into simplify-muls
prestwich Jun 15, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
61 changes: 24 additions & 37 deletions src/algorithms/mul.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -82,9 +82,7 @@ pub fn add_nx1(lhs: &mut [u64], mut a: u64) -> u64 {
return 0;
}
for lhs in lhs {
let sum = u128::add(*lhs, a);
*lhs = sum.low();
a = sum.high();
(*lhs, a) = u128::add(*lhs, a).split();
if a == 0 {
return 0;
}
Expand All @@ -107,28 +105,26 @@ pub fn addmul_n(lhs: &mut [u64], a: &[u64], b: &[u64]) {
2 => addmul_2(lhs, a, b),
3 => addmul_3(lhs, a, b),
4 => addmul_4(lhs, a, b),
_ => {
let _ = addmul(lhs, a, b);
}
_ => _ = addmul(lhs, a, b),
}
}

/// Computes `lhs += a * b` for 1 limb.
#[inline(always)]
fn addmul_1(lhs: &mut [u64], a: &[u64], b: &[u64]) {
assert_eq!(lhs.len(), 1);
assert_eq!(a.len(), 1);
assert_eq!(b.len(), 1);
assume!(lhs.len() == 1);
assume!(a.len() == 1);
assume!(b.len() == 1);

mac(&mut lhs[0], a[0], b[0], 0);
}

/// Computes `lhs += a * b` for 2 limbs.
#[inline(always)]
fn addmul_2(lhs: &mut [u64], a: &[u64], b: &[u64]) {
assert_eq!(lhs.len(), 2);
assert_eq!(a.len(), 2);
assert_eq!(b.len(), 2);
assume!(lhs.len() == 2);
assume!(a.len() == 2);
assume!(b.len() == 2);

let carry = mac(&mut lhs[0], a[0], b[0], 0);
mac(&mut lhs[1], a[0], b[1], carry);
Expand All @@ -139,9 +135,9 @@ fn addmul_2(lhs: &mut [u64], a: &[u64], b: &[u64]) {
/// Computes `lhs += a * b` for 3 limbs.
#[inline(always)]
fn addmul_3(lhs: &mut [u64], a: &[u64], b: &[u64]) {
assert_eq!(lhs.len(), 3);
assert_eq!(a.len(), 3);
assert_eq!(b.len(), 3);
assume!(lhs.len() == 3);
assume!(a.len() == 3);
assume!(b.len() == 3);

let carry = mac(&mut lhs[0], a[0], b[0], 0);
let carry = mac(&mut lhs[1], a[0], b[1], carry);
Expand All @@ -156,9 +152,9 @@ fn addmul_3(lhs: &mut [u64], a: &[u64], b: &[u64]) {
/// Computes `lhs += a * b` for 4 limbs.
#[inline(always)]
fn addmul_4(lhs: &mut [u64], a: &[u64], b: &[u64]) {
assert_eq!(lhs.len(), 4);
assert_eq!(a.len(), 4);
assert_eq!(b.len(), 4);
assume!(lhs.len() == 4);
assume!(a.len() == 4);
assume!(b.len() == 4);

let carry = mac(&mut lhs[0], a[0], b[0], 0);
let carry = mac(&mut lhs[1], a[0], b[1], carry);
Expand Down Expand Up @@ -186,10 +182,8 @@ fn mac(lhs: &mut u64, a: u64, b: u64, c: u64) -> u64 {
#[inline(always)]
pub fn mul_nx1(lhs: &mut [u64], a: u64) -> u64 {
let mut carry = 0;
for lhs in &mut *lhs {
let product = u128::muladd(*lhs, a, carry);
*lhs = product.low();
carry = product.high();
for lhs in lhs {
(*lhs, carry) = u128::muladd(*lhs, a, carry).split();
}
carry
}
Expand All @@ -206,12 +200,10 @@ pub fn mul_nx1(lhs: &mut [u64], a: u64) -> u64 {
/// $$
#[inline(always)]
pub fn addmul_nx1(lhs: &mut [u64], a: &[u64], b: u64) -> u64 {
debug_assert_eq!(lhs.len(), a.len());
assume!(lhs.len() == a.len());
let mut carry = 0;
for (lhs, a) in lhs.iter_mut().zip(a.iter().copied()) {
let product = u128::muladd2(a, b, carry, *lhs);
*lhs = product.low();
carry = product.high();
for i in 0..a.len() {
(lhs[i], carry) = u128::muladd2(a[i], b, carry, lhs[i]).split();
}
carry
}
Expand All @@ -229,21 +221,16 @@ pub fn addmul_nx1(lhs: &mut [u64], a: &[u64], b: u64) -> u64 {
// OPT: `carry` and `borrow` can probably be merged into a single var.
#[inline(always)]
pub fn submul_nx1(lhs: &mut [u64], a: &[u64], b: u64) -> u64 {
debug_assert_eq!(lhs.len(), a.len());
assume!(lhs.len() == a.len());
let mut carry = 0;
let mut borrow = 0;
for (lhs, a) in lhs.iter_mut().zip(a.iter().copied()) {
for i in 0..a.len() {
// Compute product limbs
let limb = {
let product = u128::muladd(a, b, carry);
carry = product.high();
product.low()
};
let limb;
(limb, carry) = u128::muladd(a[i], b, carry).split();

// Subtract
let (new, b) = sbb(*lhs, limb, borrow);
*lhs = new;
borrow = b;
(lhs[i], borrow) = sbb(lhs[i], limb, borrow);
}
borrow + carry
}
Expand Down