a few feature requests

[bgkillas]

hi im trying to refactor to use this in my calculator kalc(so i can actually make a website for my graphing calculator kalc-plot, since rug hard), and am missing a few things and am curious if they are planned or why they aren't.

multiplying an integer by a float, so stuff like, Mul for Decimal

parse from/output to radix for Decimals

methods for Integer types to turn into primative integers(now that i think about it maybe i should just use primative integers in the first place where i do that)

a few more things like is_prime/binom for integers but i guess those are more out of scope

thx for your time

[neogenie]

Hi @bgkillas!

Nice to meet You.

A somewhat confusing question... Could you please list the functions and methods you need in more detail, preferably with examples of their use?

[bgkillas]

ah yes sorry, i wrote that when i was tired,

I512 and D512 are placeholders since i cant remember the general term

for multiply float by decimal i mean stuff like,
impl Mul for D512 and impl Div for D512(forgot i use division also), rn i just parse the integer from a string and do this

parse from radix for decimal, so given base 3, and im displaying base 10 for simplicity, 2.1 gets parsed as, 2.33333..., as we have 3^02+3^-11, more generally, some function like
fn parse_radix(input: &str, base: u32, ...) -> D512 {}
given a string "a_na_{n-1}...a_0.a_{-1}a_{-2}...a_{m+1}a_m", given base b, it will parse
the value of the string is "sum_{i=m}^n a_i b^i"

display to radix as decimal
fn to_string_radix(self: D512, base: u32, ...) -> String {}
which pretty much just has the propery that
parse_radix(self.to_string_radix(base),base)==self

naturally you can only support so many bases, upto base 36 is what rug does iirc, so 1..=9+a..=z, so fad.124a is valid hexadecimal(base=16) roughly equal to 4013.07144165039...

for primative integer things i was thinking of
fn to_i128(self: I512) -> i128 {}
fn to_usize(self: I512) -> usize {}
etc.
but now that i look, i use these when i need to turn a float into a primative integer so to_*(self: D512) -> * would be equivalent

is_probably_prime and next_prime are two nice features in rugs integers, i use these to get prime factors for simplifying roots, is_probably_prime works on a not perfectly accurate way due to performance wants, however i never had an issue with it as i only use it for smallish numbers, so is_probably_prime(2)==IsPrime::True

next_prime gets the next prime in order, so next_prime(2)==3

i also use a fair bit would be
fn binomial(self: I512,k: I512){}, which simply equate C(self,k), or \binom{self,k}, so binomial(self,k)==factorial(self)/(factorial(k)factorial(self-k)), would be a simple implementation, alot better implementations would exist probably since the numerator would get too large fairly fast

ill eventually implement these anyways, id probably contribute upstream whenever i come around to it

thanks for your time, tell me if you want more info