Господа, я тут решил реализовать алгоритм Диффи-Хеллмана. А для него

нужна длинная арфметика. Не подскажете ли, где её взять?

Вроде был крейт

ныа, держи: use std::ops::{Add, Mul}; #[derive(Debug, Clone)] struct BigInteger { data: Vec<u32>, } impl BigInteger { fn new(value: u64) -> Self { let mut data = Vec::new(); let mut v = value; while v > 0 { data.push((v % 10_000) as u32); // Store in chunks of 10,000 for simplicity v /= 10_000; } BigInteger { data } } } // Addition for BigInteger impl Add for BigInteger { type Output = Self; fn add(self, other: Self) -> Self { let mut result = BigInteger { data: Vec::new() }; let mut carry = 0; for i in 0..std::cmp::max(self.data.len(), other.data.len()) { let sum = carry + self.data.get(i).cloned().unwrap_or(0) + other.data.get(i).cloned().unwrap_or(0); result.data.push(sum % 10_000); carry = sum / 10_000; } if carry > 0 { result.data.push(carry); } result } } // Multiplication for BigInteger impl Mul for BigInteger { type Output = Self; fn mul(self, other: Self) -> Self { let mut result = BigInteger { data: vec![0] }; for (i, &digit_self) in self.data.iter().enumerate() { let mut carry = 0; for (j, &digit_other) in other.data.iter().enumerate() { let product = result.data[i + j] + digit_self * digit_other + carry; result.data[i + j] = product % 10_000; carry = product / 10_000; } if carry > 0 { result.data.push(carry); } } result } } fn main() { let num1 = BigInteger::new(12345678901234567890); let num2 = BigInteger::new(98765432109876543210); let sum = num1.clone() + num2.clone(); let product = num1 * num2; println!("Num1: {:?}", num1); println!("Num2: {:?}", num2); println!("Sum: {:?}", sum); println!("Product: {:?}", product); }

Если что-то не работает в нём, все претензии к нему

Прям-таки длинная? ПОтому что есть U256/U512, а если их недостаточно можно форкнуть либу и добавить U нужного размера

Выглядит как-то не очень производительно и экономно

Alexander "SonnySlave" Zaitsev
есть и другой вариант

Ты не получишь от нейронки нормальный вариант

Это ты просто на стадии отрицания

нет. я просто знаю что молотком плохо закручивать гайки

Ну скинь нормальный ответ

это всё отговорки, чтобы Copilot хлеб не отобрал в том числе и у ржавых

а, да, конечно

use std::ops::{Add, Mul}; #[derive(Debug, Clone)] struct BigInteger { data: Vec<u32>, } impl BigInteger { fn new(value: u64) -> Self { let mut data = vec![(value % 10_000) as u32]; let mut v = value / 10_000; while v > 0 { data.push((v % 10_000) as u32); v /= 10_000; } BigInteger { data } } } // Addition for BigInteger impl Add for BigInteger { type Output = Self; fn add(self, other: Self) -> Self { let (mut result, mut carry) = (BigInteger { data: Vec::new() }, 0); for (a, b) in self.data.iter().zip_longest(other.data.iter()) { let sum = a.cloned().unwrap_or(0) + b.cloned().unwrap_or(0) + carry; result.data.push(sum % 10_000); carry = sum / 10_000; } if carry > 0 { result.data.push(carry); } result } } // Multiplication for BigInteger impl Mul for BigInteger { type Output = Self; fn mul(self, other: Self) -> Self { let mut result = vec![0; self.data.len() + other.data.len()]; for (i, &digit_self) in self.data.iter().enumerate() { let mut carry = 0; for (j, &digit_other) in other.data.iter().enumerate() { let product = result[i + j] + digit_self * digit_other + carry; result[i + j] = product % 10_000; carry = product / 10_000; } if carry > 0 { result[i + other.data.len()] += carry; } } while let Some(&0) = result.last() { result.pop(); } BigInteger { data: result } } } Держи - это safe и blazing fast реализация длинки

это не блазинг фаст а мусор

Alexander "SonnySlave" Zaitsev
с тобой не согласны

тебе варн за спам/флейм крч

а ты так и не дал аргумента, чем эта реализация "мусор" (как резонно коллега на скрине выше заметил)

Начнем с того что хранить чанки по 10к вместо u32::MAX это вот сразу кринж

почему в реализации суммы используются деления

ну это имело бы смысл, если умножать через FFT

Но согласен, при при тупом умножении за квадрат как тут выходит кринж

Не думаю, что в fft требуется кратность степени десятки

Alexander "SonnySlave" Zaitsev
с тобой не согласны

Оно каждое сообщение про Раст начинает с дисклеймера про владения и аллокации?

Там требуется, чтобы digit^2 * digit_count не округлилось

на практике можно сразу брать какой нибудь __mm и не париться. Сложно представить где будет не достаточно 512 битных интов или сколько там сейчас. Думаю компилятор примерно так и сделает если не пессимизировать

8килобитные регистры в Интел?