Absolute value

[mattfbacon]

I would like to have a way to make a BigInt into its absolute value in place, i.e. taking &mut self. Seems like a good approach would be to add an abs method to Sign which is just

match self {
  Self::NoSign => Self::NoSign,
  Self::Minus | Self::Plus => Self::Plus,
}

and then in BigInt it would be

self.sign = self.sign.abs();

If this approach is acceptable I can make a PR.

[cuviper]

I don't think we need anything added to Sign, just:

impl BigInt {
    fn bikeshed_abs_in_place(&mut self) {
        if self.sign == Sign::Minus {
            self.sign = Sign::Plus;
        }
    }
}

This seems ok, but the hard part is to find a good name for it. :)

If you have ownership, you can use BigInt::from(bigint.into_parts().1), and maybe that deserves fn into_abs(self). From there you can also fake in-place on &mut by using mem::take to steal the value and then write it back.

[mattfbacon]

Okay, those approaches seem better to me. I especially like the BigInt::from approach.

Anyway, assuming the implementation you gave, do you think that BigInt::abs is not a good name?

[cuviper]

There is already an abs(&self) through the Signed trait:
https://docs.rs/num-bigint/latest/num_bigint/struct.BigInt.html#method.abs

[mattfbacon]

Ah, how about make_abs then.

[cuviper]

Yeah, make_abs sounds ok. There's some precedent in std with make_ascii_upper/lower_case, make_contiguous, and make_mut.

[youknowone]

instead of &mut, how about fn into_abs(self)?