diff --git a/number/atom.go b/number/atom.go
deleted file mode 100644
index 2b71510..0000000
--- a/number/atom.go
+++ /dev/null
@@ -1,502 +0,0 @@
-package number
-
-import (
-	"math/big"
-
-	"gitea.zaclys.com/bvaudour/gob/option"
-)
-
-type atom struct {
-	number option.Option[*big.Rat]
-	sign   int
-}
-
-func undefined[S integer | float](sign S) atom {
-	out := atom{
-		sign: signOf(sign),
-	}
-
-	return out.format()
-}
-
-func rational[S integer | float](rat *big.Rat, sign ...S) atom {
-	s := 1
-	if len(sign) > 0 {
-		s = signOf(sign[0])
-	}
-
-	out := atom{
-		number: option.Some(rat),
-		sign:   s,
-	}
-
-	return out.format()
-}
-
-func frac0[S integer | float](num, denom *big.Int, sign ...S) atom {
-	if denom.IsInt64() && denom.Int64() == 0 {
-		s := num.Sign()
-		if len(sign) > 0 {
-			s *= signOf(sign[0])
-		}
-		return undefined(s)
-	}
-
-	rat := new(big.Rat).SetFrac(num, denom)
-	return rational(rat, sign...)
-}
-
-func frac[N integer | float, S integer | float](num, denom N, sign ...S) atom {
-	if denom == 0 {
-		s := signOf(num)
-		if len(sign) > 0 {
-			s *= signOf(sign[0])
-		}
-		return undefined(s)
-	}
-
-	rat := new(big.Rat).SetFrac64(int64(num), int64(denom))
-	return rational(rat, sign...)
-}
-
-func entire0[S integer | float](n *big.Int, sign ...S) atom {
-	rat := new(big.Rat).SetInt(n)
-
-	return rational(rat, sign...)
-}
-
-func entire[N integer | float, S integer | float](n N, sign ...S) atom {
-	rat := new(big.Rat).SetInt64(int64(n))
-
-	return rational(rat, sign...)
-}
-
-func decimal[N integer | float, S integer | float](n N, sign ...S) atom {
-	rat := new(big.Rat).SetFloat64(float64(n))
-
-	return rational(rat, sign...)
-}
-
-func pow[B integer | float, P integer | float](base B, precision ...P) atom {
-	p := FloatingPrecision
-	if len(precision) > 0 {
-		p = uint64(precision[0])
-	}
-
-	a := entire(formatBase(base), 1)
-	return a.pow(p)
-}
-
-func (a atom) get() (*big.Rat, bool) {
-	return a.number.Get()
-}
-
-func (a *atom) format() atom {
-	if nb, ok := a.get(); ok {
-		a.sign *= nb.Sign()
-		nb.Abs(nb)
-	}
-
-	a.sign = signOf(a.sign)
-	return *a
-}
-
-func (a atom) clone(format ...bool) atom {
-	out := atom{
-		sign: a.sign,
-	}
-	if nb, ok := a.get(); ok {
-		out.number = option.Some(new(big.Rat).Set(nb))
-	}
-
-	if len(format) > 0 && format[0] {
-		return out.format()
-	}
-	return out
-}
-
-func (a atom) rat() (nb *big.Rat, ok bool) {
-	if nb, ok = a.get(); ok {
-		nb = new(big.Rat).Set(nb)
-		if a.sign < 0 {
-			nb.Neg(nb)
-		} else if a.sign == 0 {
-			nb.SetInt64(0)
-		}
-	}
-
-	return
-}
-
-func (a atom) Sign() int {
-	return a.sign
-}
-
-func (a atom) IsNeg() bool {
-	return a.Sign() < 0
-}
-
-func (a atom) IsPos() bool {
-	return !a.IsNeg()
-}
-
-func (a atom) IsZero() bool {
-	return a.Is(0)
-}
-
-func (a atom) neg() atom {
-	out := a.clone()
-	out.sign = -out.sign
-
-	return out.format()
-}
-
-func (a atom) abs() atom {
-	out := a.clone()
-	if out.sign < 0 {
-		out.sign = -out.sign
-	}
-
-	return out.format()
-}
-
-func (a atom) IsDefined() bool {
-	return a.number.IsDefined()
-}
-
-func (a atom) IsInf() bool {
-	return !a.IsDefined() && a.Sign() > 0
-}
-
-func (a atom) IsNegInf() bool {
-	return !a.IsDefined() && a.Sign() < 0
-}
-
-func (a atom) IsNan() bool {
-	return !a.IsDefined() && a.Sign() == 0
-}
-
-func (a atom) Is(i int64) bool {
-	if nb, ok := a.get(); ok {
-		return nb.IsInt() && nb.Num().Int64()*int64(a.Sign()) == i
-	}
-
-	return false
-}
-
-func (a atom) IsFloat(f float64) bool {
-	if nb, ok := a.get(); ok {
-		e, ok := nb.Float64()
-		return ok && e*float64(a.Sign()) == f
-	}
-
-	return false
-}
-
-func (a atom) isInt() bool {
-	if nb, ok := a.get(); ok {
-		return nb.IsInt()
-	}
-
-	return false
-}
-
-func (a atom) isInt64() bool {
-	if nb, ok := a.get(); ok {
-		return nb.IsInt() && nb.Num().IsInt64()
-	}
-	return false
-}
-
-func (a atom) toInt64() (n int64, ok bool) {
-	var nb *big.Rat
-	if nb, ok = a.get(); ok {
-		if nb.IsInt() {
-			if num := nb.Num(); num.IsInt64() {
-				n = num.Int64()
-			}
-		}
-	}
-
-	return
-}
-
-func (a *atom) setInt() atom {
-	if nb, ok := a.get(); ok {
-		nb.SetInt(new(big.Int).Quo(nb.Num(), nb.Denom()))
-	}
-
-	return a.format()
-}
-
-func (a atom) num() atom {
-	if a.Sign() == 0 {
-		return entire(0, 0)
-	} else if nb, ok := a.get(); ok {
-		return entire0(nb.Num(), a.Sign())
-	}
-
-	return entire(a.Sign(), 1)
-}
-
-func (a atom) denom() atom {
-	if nb, ok := a.get(); ok {
-		return entire0(nb.Denom(), 1)
-	}
-
-	return entire(0, 0)
-}
-
-func (a1 atom) cmp(a2 atom) int {
-	if a1.IsNan() {
-		if a2.IsNan() {
-			return 0
-		}
-		return -2
-	} else if a2.IsNan() {
-		return 2
-	} else if nb1, ok := a1.rat(); ok {
-		if nb2, ok := a2.rat(); ok {
-			return nb1.Cmp(nb2)
-		}
-		return -a2.Sign()
-	} else if a2.IsDefined() {
-		return a1.Sign()
-	}
-
-	return compare(a1.Sign(), a2.Sign())
-}
-
-func (a1 atom) add(a2 atom) atom {
-	if r1, ok := a1.rat(); ok {
-		if r2, ok := a2.rat(); ok {
-			return rational(new(big.Rat).Add(r1, r2), 1)
-		}
-		return a2.clone()
-	} else if a2.IsDefined() || a1.Sign() == a2.Sign() {
-		return undefined(a1.Sign())
-	}
-
-	return undefined(0)
-}
-
-func (a1 atom) sub(a2 atom) atom {
-	return a1.add(a2.neg())
-}
-
-func (a atom) inc() atom {
-	return a.add(entire(1, 1))
-}
-
-func (a atom) dec() atom {
-	return a.sub(entire(1, 1))
-}
-
-func (a1 atom) mul(a2 atom) atom {
-	s := a1.Sign() * a2.Sign()
-	if nb1, ok := a1.get(); ok {
-		if nb2, ok := a2.get(); ok {
-			return rational(new(big.Rat).Mul(nb1, nb2), s)
-		}
-	}
-
-	return undefined(s)
-}
-
-func (a1 atom) div(a2 atom) atom {
-	if nb1, ok := a1.get(); ok {
-		if nb2, ok := a2.get(); ok {
-			if nb2.IsInt() && nb2.Num().IsInt64() && nb2.Num().Int64() == 0 {
-				return undefined(0)
-			}
-			return rational(new(big.Rat).Quo(nb1, nb2), a1.Sign()*a2.Sign())
-		}
-		return undefined(a1.Sign() * a2.Sign())
-	} else if a2.IsDefined() {
-		return undefined(a1.Sign() * a2.Sign())
-	}
-
-	return undefined(0)
-}
-
-func (a1 atom) quo(a2 atom) atom {
-	if nb1, ok := a1.get(); ok {
-		if nb2, ok := a2.get(); ok {
-			if nb2.IsInt() && nb2.Num().IsInt64() && nb2.Num().Int64() == 0 {
-				return undefined(0)
-			}
-			n := new(big.Int).Mul(nb1.Num(), nb2.Num())
-			d := new(big.Int).Mul(nb1.Denom(), nb2.Denom())
-			return entire0(new(big.Int).Quo(n, d), a1.Sign()*a2.Sign())
-		}
-		return undefined(a1.Sign() * a2.Sign())
-	} else if a2.IsDefined() {
-		return undefined(a1.Sign() * a2.Sign())
-	}
-
-	return undefined(0)
-}
-
-func (a1 atom) quoRem(a2 atom) (q, r atom) {
-	q = a1.quo(a2)
-	r = a1.sub(a2.mul(q))
-
-	return
-}
-
-func (a1 atom) rem(a2 atom) atom {
-	_, r := a1.quoRem(a2)
-	return r
-}
-
-func (a atom) inv() atom {
-	if nb, ok := a.get(); ok {
-		n, d := nb.Num(), nb.Denom()
-		return frac0(d, n, a.Sign())
-	}
-
-	if a.Sign() == 0 {
-		return undefined(0)
-	}
-	return entire(0, 0)
-}
-
-func (a atom) pow(p uint64) atom {
-	switch {
-	case p == 0:
-		if a.IsNan() {
-			return undefined(0)
-		}
-		return entire(0, 0)
-	case p == 1:
-		return a.clone(true)
-	case p == 2:
-		return a.mul(a)
-	case p&1 == 0:
-		return a.mul(a).pow(p >> 1)
-	default:
-		return a.mul(a).pow(p >> 1).mul(a)
-	}
-}
-
-func (a atom) optimize(precision atom) atom {
-	if a.isInt() || !a.IsDefined() {
-		return a
-	}
-
-	n1, d1 := a.num().abs(), a.denom()
-	t := n1.mul(precision).quo(d1)
-	an := t.div(precision)
-	n2, d2 := an.num(), an.denom()
-	if n2.cmp(n1) < 0 || d2.cmp(d1) < 0 {
-		t.sign = a.sign
-		return t.format()
-	}
-
-	return a
-}
-
-func (a atom) heron(n uint64, tmp atom) atom {
-	n0 := entire(int64(n), 1)
-	n1 := n0.dec()
-
-	return ((tmp.mul(n1)).add(a.div(tmp.pow(n - 1)))).div(n0)
-}
-
-func (a atom) sqrtn(n uint64, base uint) atom {
-	switch {
-	case a.IsNan() || n < 2 || (a.IsNeg() && n&1 == 0):
-		return undefined(0)
-	case a.IsZero() || a.Is(1) || !a.IsDefined():
-		return a.clone(true)
-	default:
-		precision := pow(base, FloatingPrecision)
-		pi := precision.inv()
-		out := a.heron(n, a).optimize(precision)
-		for {
-			t := a.heron(n, out).optimize(precision)
-			if out.cmp(t) == 0 {
-				break
-			} else if out.sub(t).abs().cmp(pi) < 0 {
-				out = t
-				break
-			}
-		}
-
-		return out
-	}
-}
-
-func (a atom) IsEven() bool {
-	if nb, ok := a.get(); ok {
-		return nb.IsInt() && nb.Num().Bit(0) == 0
-	}
-
-	return false
-}
-
-func (a atom) IsOdd() bool {
-	if nb, ok := a.get(); ok {
-		return nb.IsInt() && nb.Num().Bit(0) != 0
-	}
-
-	return false
-}
-
-func (a atom) lsh(n uint) atom {
-	if nb, ok := a.get(); ok {
-		if nb.IsInt() {
-			num, denom := new(big.Int).Lsh(nb.Num(), n), nb.Denom()
-			return frac0(num, denom, a.Sign())
-		}
-		return a.mul(pow(2, n))
-	}
-
-	return undefined(a.Sign())
-}
-
-func (a atom) rsh(n uint) atom {
-	if nb, ok := a.get(); ok {
-		if nb.IsInt() {
-			num, denom := new(big.Int).Rsh(nb.Num(), n), nb.Denom()
-			return frac0(num, denom, a.Sign())
-		}
-		return a.div(pow(2, n))
-	}
-
-	return undefined(a.Sign())
-}
-
-func (a atom) len(base uint) int {
-	if nb, ok := a.get(); ok {
-		if !nb.IsInt() {
-			return -1
-		}
-		num := nb.Num()
-		if num.IsInt64() && num.Int64() == 0 {
-			return 1
-		}
-		s := num.Text(int(base))
-		return len(s)
-	}
-
-	return -1
-}
-
-func (a atom) bit(n uint64, base uint) int {
-	if !a.isInt() {
-		return -1
-	}
-
-	out := a
-	if n > 0 {
-		out = a.quo(pow(base, n))
-	}
-
-	out = out.rem(entire(base, 1))
-	if nb, ok := out.get(); ok {
-		return int(nb.Num().Int64())
-	}
-
-	return -1
-}
diff --git a/number/const.go b/number/const.go
index 9ad31da..3a1ee97 100644
--- a/number/const.go
+++ b/number/const.go
@@ -7,42 +7,56 @@ import (
 
 var (
 	FloatingPrecision uint64 = 10    // Nombre de chiffres après la virgule pour un nombre décimal ou un nombre scientifique
-	FixedPrecision           = false // Si vrai le nombre chiffre après la virgule est fixe.
+	FixedPrecision           = false // Si vrai le nombre de chiffres après la virgule est fixe.
 )
 
 const (
-	regSign   = `\+|-`
-	regBSign  = `0|1`
-	regBase   = `\(\d+\)`
-	regBase2  = `B|b`
-	regBase8  = `O|o`
-	regBase16 = `X|x`
-	regNb     = `[0-9a-zA-Z]`
-	regNb2    = `0|1`
-	regNb8    = `[0-7]`
-	regNb10   = `\d`
-	regNb16   = `[0-9a-fA-F]`
-	regExp    = `×\d+\^`
-	regExp10  = `E|e`
+	rSign   = `(\+|-)`
+	rBSign  = `(0|1)`
+	rNb2    = `(0|1)`
+	rNb8    = `[0-7]`
+	rNb10   = `\d`
+	rNb16   = `[0-9a-fA-F]`
+	rNbN    = `[0-9a-zA-Z]`
+	rBase2  = `(B|b)`
+	rBase8  = `(O|o)`
+	rBase16 = `(X|x)`
+	rExp10  = `E|e`
+	rExpN   = `×\d+\^`
 )
 
 var (
-	regInt   = regexp.MustCompile(fmt.Sprintf(`%s(%s)?%s+`, regBase, regSign, regNb))
-	regInt2  = regexp.MustCompile(fmt.Sprintf(`(%s)(%s)(%s)+`, regBSign, regBase2, regNb2))
-	regInt8  = regexp.MustCompile(fmt.Sprintf(`(%s)(%s)(%s)+`, regBSign, regBase8, regNb8))
-	regInt10 = regexp.MustCompile(fmt.Sprintf(`(%s)?%s+`, regSign, regNb10))
-	regInt16 = regexp.MustCompile(fmt.Sprintf(`(%s)(%s)(%s)+`, regBSign, regBase16, regNb16))
+	rInt2  = fmt.Sprintf(`(%s)%s+`, rBase2, rNb2)
+	rInt8  = fmt.Sprintf(`(%s)%s+`, rBase8, rNb8)
+	rInt10 = fmt.Sprintf(`(%s)%s+`, rSign, rNb10)
+	rInt16 = fmt.Sprintf(`(%s)%s+`, rBase8, rNb8)
+	rIntN  = fmt.Sprintf(`\(%s+\)%s?%s+`, rNb10, rSign, rNbN)
+	rIntB  = fmt.Sprintf(`%s(%s|%s|%s)`, rBSign, rInt2, rInt8, rInt16)
+	rInt   = fmt.Sprintf(`(%s|%s|%s)`, rInt10, rIntN, rIntB)
 
-	regDec   = regexp.MustCompile(fmt.Sprintf(`%s(%s)?(%s*\.%s+|%s+\.)`, regBase, regSign, regNb, regNb, regNb))
-	regDec2  = regexp.MustCompile(fmt.Sprintf(`(%s)(%s)((%s)*\.(%s)+|(%s)+\.)`, regBSign, regBase2, regNb2, regNb2, regNb2))
-	regDec8  = regexp.MustCompile(fmt.Sprintf(`(%s)(%s)((%s)*\.(%s)+|(%s)+\.)`, regBSign, regBase8, regNb8, regNb8, regNb8))
-	regDec10 = regexp.MustCompile(fmt.Sprintf(`(%s)?(%s*\.%s+|%s+\.)`, regSign, regNb10, regNb10, regNb10))
-	regDec16 = regexp.MustCompile(fmt.Sprintf(`(%s)(%s)((%s)*\.(%s)+|(%s)+\.)`, regBSign, regBase16, regNb16, regNb16, regNb16))
-
-	regFrac   = regexp.MustCompile(fmt.Sprintf(`%s(%s)?%s+/(%s)?%s+`, regBase, regSign, regNb, regSign, regNb))
-	regFrac10 = regexp.MustCompile(fmt.Sprintf(`(%s)?%s+/(%s)?%s+`, regSign, regNb10, regSign, regNb10))
-
-	regSci         = regexp.MustCompile(fmt.Sprintf(`%s(%s)?(%s*\.%s+|%s+\.?)%s(%s)?(%s)+`, regBase, regSign, regNb, regNb, regNb, regExp, regSign, regNb10))
-	regSci10Simple = regexp.MustCompile(fmt.Sprintf(`%s(%s)?(%s*\.%s+|%s+\.?)`, regSign, regNb10, regNb10, regNb10, regExp, regSign, regNb10))
-	regSci10       = regexp.MustCompile(fmt.Sprintf(`%s(%s)?(%s*\.%s+|%s+\.?)`, regSign, regNb10, regNb10, regNb10, regExp10, regSign, regNb10))
+	rDec2       = fmt.Sprintf(`(%s)(%s+\.%s*|\.%s+)`, rBase2, rNb2, rNb2, rNb2)
+	rDec8       = fmt.Sprintf(`(%s)(%s+\.%s*|\.%s+)`, rBase8, rNb8, rNb8, rNb8)
+	rDec10      = fmt.Sprintf(`%s?(%s+\.%s*|\.%s+)`, rSign, rNb10, rNb10, rNb10)
+	rDec16      = fmt.Sprintf(`(%s)(%s+\.%s*|\.%s+)`, rBase16, rNb16, rNb16, rNb16)
+	rDecN       = fmt.Sprintf(`\(%s+\)%s?(%s+\.%s*|\.%s+)`, rNb10, rSign, rNbN, rNbN, rNbN)
+	rDecB       = fmt.Sprintf(`%s(%s|%s|%s)`, rBSign, rDec2, rDec8, rDec16)
+	rDec        = fmt.Sprintf(`(%s|%s|%s)`, rDec10, rDecN, rDecB)
+	rExponent10 = fmt.Sprintf(`(%s|%s)(%s)%s?%s+`, rInt10, rDec10, rExp10, rSign, rNb10)
+	rExponentN  = fmt.Sprintf(`(%s|%s)%s%s?%s+`, rInt, rDec, rExpN, rSign, rNb10)
+	rAll10      = fmt.Sprintf(`(%s|%s)((%s)%s?%s+)?`, rInt10, rDec10, regExp10, rSign, rNb10)
+	rAllN       = fmt.Sprintf(`(%s|%s)(%s%s?%s+)?`, rInt, rDec, rExpN, rSign, rNb10)
+	rAll        = fmt.Sprintf(`(%s|%s)`, rAll10, rAllN)
+)
+
+var (
+	regInt10 = regexp.MustCompile(fmt.Sprintf(`^%s$`, rInt10))
+	regIntN  = regexp.MustCompile(fmt.Sprintf(`^%s$`, rIntN))
+	regIntB  = regexp.MustCompile(fmt.Sprintf(`^%s$`, rIntB))
+
+	regDec = regexp.MustCompile(fmt.Sprintf(`^%s$`, rDec))
+
+	regExp10 = regexp.MustCompile(fmt.Sprintf(`^%s$`, rExponent10))
+	regExpN  = regexp.MustCompile(fmt.Sprintf(`^%s$`, rExpN))
+
+	regFrac = regexp.MustCompile(fmt.Sprintf(`^%s/%s$`, rAll, rAll))
 )
diff --git a/number/convert.go b/number/convert.go
index 9b7c44d..39bcfa7 100644
--- a/number/convert.go
+++ b/number/convert.go
@@ -9,160 +9,109 @@ import (
 	"gitea.zaclys.com/bvaudour/gob/option"
 )
 
-func undefinedString(sign int) string {
-	switch sign {
-	case -1:
-		return "-∞"
-	case +1:
-		return "+∞"
-	default:
-		return "NaN"
+// Undefined retourne un nombre indéfini, signé :
+// - si sign < 0, retourne -∞
+// - si sign > 0, retourne +∞
+// - sinon, retourne NaN
+func Undefined[N integer | float](sign N) Number {
+	return Number{
+		base: 10,
+		tpe:  Integer,
+		sign: signOf(sign),
 	}
 }
 
-func integerString(n *big.Int, base uint, sign int) string {
-	out := n.Text(int(base))
+// Nan retourne NaN.
+func Nan() Number { return Undefined(0) }
 
-	if sign < 0 {
-		out = fmt.Sprintf("-%s", out)
+// Inf retourne +∞.
+func Inf() Number { return Undefined(1) }
+
+// NegInf retourne -∞.
+func NegInf() Number { return Undefined(-1) }
+
+// IntOf0 retourne un nombre entier à partir d’un entier, et éventuellement une base.
+func IntOf0(i *big.Int, base ...uint) Number {
+	if i == nil {
+		return Nan()
 	}
 
-	if base != 10 {
-		out = fmt.Sprintf("(%d)%s", base, out)
+	n := Number{
+		number: option.Some(new(big.Rat).SetInt(i)),
+		sign:   1,
+		base:   formatBase(base...),
+		tpe:    Integer,
 	}
 
-	return out
+	return n.format()
 }
 
-func fractionString(n, d *big.Int, base uint, sign int) string {
-	out := fmt.Sprintf("%s/%s", n.Text(int(base)), d.Text(int(base)))
-
-	if sign < 0 {
-		out = fmt.Sprintf("-%s", out)
-	}
-
-	if base != 10 {
-		out = fmt.Sprintf("(%d)%s", base, out)
-	}
-
-	return out
+// IntOf retourne un nombre entier à partir d’un entier, et éventuellement une base.
+func IntOf[N integer | float](i N, base ...uint) Number {
+	return IntOf0(new(big.Int).SetInt64(int64(i)), base...)
 }
 
-func decimalString(n Number) string {
-	base := n.Base()
-	num, denom := n.num(), n.denom()
-	p := pow(base, FloatingPrecision)
-	num = num.mul(p)
-	q := num.quo(denom)
-
-	out := "0"
-	if num.cmp(denom) >= 0 {
-		if qn, ok := q.get(); ok {
-			out = qn.Num().Text(int(base))
-		} else {
-			return ""
-		}
+func pow[N integer | float, M integer | float](b N, p ...M) Number {
+	if len(p) > 0 {
+		return IntOf(b).pow(int64(p[0]))
 	}
-
-	precision := int(FloatingPrecision)
-	if len(out) < precision {
-		out = fmt.Sprintf("%s%s", strings.Repeat("0", precision), out)
-	}
-
-	deltaPrecision := len(out) - precision
-	out = fmt.Sprintf("%s.%s", out[:deltaPrecision], out[deltaPrecision:])
-
-	if !FixedPrecision {
-		l := len(out) - 1
-		for out[l] == '0' {
-			out, l = out[:l], l-1
-		}
-		if out == "." {
-			out = "0."
-		}
-	}
-
-	if n.IsNeg() {
-		out = fmt.Sprintf("-%s", out)
-	} else if q.IsZero() && !n.IsZero() {
-		out = fmt.Sprintf("+%s", out)
-	}
-
-	if base != 10 {
-		out = fmt.Sprintf("(%d)%s", base, out)
-	}
-
-	return out
+	return IntOf(b).pow(int64(FloatingPrecision))
 }
 
-func scientificStsring(n Number) string {
-	base := n.Base()
-	var exponent int
-	tmp := n
-	if n.IsZero() {
-		num, denom := n.Abs().NumDenom()
-		nl, dl := num.Len(), denom.Len()
-		exponent := nl - dl
-		if exponent > 0 {
-			denom = denom.Mul(Number{
-				base: base,
-				tpe:  Integer,
-				atom: pow(base, exponent),
-			})
-		} else if exponent < 0 {
-			num = num.Mul(Number{
-				base: base,
-				tpe:  Integer,
-				atom: pow(base, -exponent),
-			})
-		}
+// Zero retourne le nombre 0.
+func Zero(base ...uint) Number { return IntOf(0, base...) }
 
-		if num.Lt(denom) {
-			exponent--
-			num.Mul(Int(base, base))
-		}
-		tmp = num.Div(denom)
+// One retourne le nombre 1.
+func One(base ...uint) Number { return IntOf(1, base...) }
+
+// Two retourne le nombre 2.
+func Two(base ...uint) Number { return IntOf(2, base...) }
+
+// DecOf0 retourne un nombre décimal à partir d’un rationnel.
+func DecOf0(f *big.Rat, base ...uint) Number {
+	if f == nil {
+		return Nan()
 	}
 
-	out := decimalString(tmp)
-
-	signExponent := ""
-	if exponent > 0 {
-		signExponent = "+"
-	} else if exponent < 0 {
-		signExponent = "-"
+	n := Number{
+		number: option.Some(new(big.Rat).Set(f)),
+		sign:   1,
+		base:   formatBase(base...),
+		tpe:    Decimal,
 	}
 
-	if base == 10 {
-		return fmt.Sprintf("%sE%s%d", out, signExponent, exponent)
-	}
-	return fmt.Sprintf("%s×%d^%s%d", out, base, signExponent, exponent)
+	return n.format()
 }
 
-// String retourne la représentation du nombre sous forme de chaîne de caractères.
-func (n Number) String() string {
-	if nb, ok := n.get(); ok {
-		switch n.Type() {
-		case Integer:
-			return integerString(nb.Num(), n.Base(), n.Sign())
-		case Fraction:
-			return fractionString(nb.Num(), nb.Denom(), n.base, n.Sign())
-		case Scientific:
-			return scientificStsring(n)
-		default:
-			return decimalString(n)
-		}
-	}
-
-	return undefinedString(n.Sign())
+// DecOf retourne un nombre décimal à partir d’un flottant.
+func DecOf[N integer | float](f float64, base ...uint) Number {
+	return DecOf0(new(big.Rat).SetFloat64(float64(f)))
 }
 
-func parseBase(str string) (next string, base option.Option[uint]) {
+// FracOf0 retourne une fraction à partir d’un numérateur et d’un dénominateur entiers.
+func FracOf0(num, denom *big.Int, base ...uint) Number {
+	if num == nil || denom == nil {
+		return Nan()
+	}
+
+	n := Number{
+		number: option.Some(new(big.Rat).SetFrac(num, denom)),
+		sign:   1,
+		base:   formatBase(base...),
+		tpe:    Fraction,
+	}
+
+	return n.format()
+}
+
+// FracOf retourne une fraction à partir d’un numérateur et d’un dénominateur entiers.
+func FracOf[N integer | float](num, denom N, base ...uint) Number {
+	return FracOf0(new(big.Int).SetInt64(int64(num)), new(big.Int).SetInt64(int64(denom)), base...)
+}
+
+func parseBaseN(str string) (next string, base option.Option[uint]) {
 	begin := strings.Index(str, "(")
 	end := strings.Index(str, ")")
-	if begin > end || begin < 0 || end < 0 {
-		return
-	}
 
 	next = str[end+1:]
 	if b, err := strconv.ParseUint(str[begin+1:end], 10, 64); err == nil && isBaseValid(b) {
@@ -171,7 +120,7 @@ func parseBase(str string) (next string, base option.Option[uint]) {
 	return
 }
 
-func parseBaseN(str string) (next string, base uint) {
+func parseBaseB(str string) (next string, base uint) {
 	next = str[1:]
 	switch str[0] {
 	case 'B', 'b':
@@ -185,7 +134,7 @@ func parseBaseN(str string) (next string, base uint) {
 	return
 }
 
-func parseSign(str string) (next string, sign int) {
+func parseSignN(str string) (next string, sign int) {
 	switch str[0] {
 	case '-':
 		next, sign = str[1:], -1
@@ -198,7 +147,7 @@ func parseSign(str string) (next string, sign int) {
 	return
 }
 
-func parseSignN(str string) (next string, sign int) {
+func parseSignB(str string) (next string, sign int) {
 	next, sign = str[1:], 1
 	if str[0] == '1' {
 		sign = -1
@@ -217,226 +166,40 @@ func parseNumber(str string, base uint) (n option.Option[*big.Int]) {
 
 func setInt(str string, base uint, sign int) (n option.Option[Number]) {
 	if nb, ok := parseNumber(str, base).Get(); ok {
-		nn := Number{
-			base: base,
-			tpe:  Integer,
-			atom: entire0(nb, sign),
+		if sign < 0 {
+			nb.Neg(nb)
 		}
-		n = option.Some(nn.format())
-	}
-
-	return
-}
-
-func parseInt(str string) (n option.Option[Number]) {
-	next, base := parseBase(str)
-
-	if b, ok := base.Get(); ok {
-		next, sign := parseSign(next)
-		n = setInt(next, b, sign)
+		n = option.Some(IntOf0(nb, base))
 	}
 
 	return
 }
 
 func parseInt10(str string) (n option.Option[Number]) {
-	next, sign := parseSign(str)
+	next, sign := parseSignN(str)
 
 	return setInt(next, 10, sign)
 }
 
-func parseIntN(str string) (n option.Option[Number]) {
-	next, sign := parseSignN(str)
-	next, base := parseBaseN(next)
+func parseIntB(str string) (n option.Option[Number]) {
+	next, sign := parseSignB(str)
+	next, base := parseBaseB(next)
 
 	return setInt(next, base, sign)
 }
 
-func setFrac(str string, base uint, sign int) (n option.Option[Number]) {
-	i := strings.Index(str, "/")
-	if i < 0 {
-		return
-	}
-
-	sNum, sDenom := str[:i], str[i:]
-	if num, ok := parseNumber(sNum, base).Get(); ok {
-		if denom, ok := parseNumber(sDenom, base).Get(); ok {
-			nn := Number{
-				base: base,
-				tpe:  Fraction,
-				atom: frac0(num, denom, sign),
-			}
-			n = option.Some(nn.format())
-		}
-	}
-
-	return
-}
-
-func parseFrac(str string) (n option.Option[Number]) {
-	next, base := parseBase(str)
-
+func parseIntN(str string) (n option.Option[Number]) {
+	next, base := parseBaseN(str)
 	if b, ok := base.Get(); ok {
-		next, sign := parseSign(next)
-		n = setFrac(next, b, sign)
-	}
-
-	return
-}
-
-func parseFrac10(str string) (n option.Option[Number]) {
-	next, sign := parseSign(str)
-
-	return setFrac(next, 10, sign)
-}
-
-func parseDot(str string) (next string, dot int) {
-	i := strings.Index(str, ".")
-	if i >= 0 {
-		next = str[:i] + str[:i]
-		dot = len(next) - i
-	}
-
-	return
-}
-
-func setDec(str string, base uint, sign int) (n option.Option[Number]) {
-	next, dot := parseDot(str)
-
-	if num, ok := parseNumber(next, base).Get(); ok {
-		denom := pow(base, dot)
-		nn := Number{
-			base: base,
-			tpe:  Decimal,
-			atom: entire0(num, sign).div(denom),
-		}
-		n = option.Some(nn.format())
-	}
-
-	return
-}
-
-func parseDec(str string) (n option.Option[Number]) {
-	next, base := parseBase(str)
-
-	if b, ok := base.Get(); ok {
-		next, sign := parseSign(next)
-		n = setDec(next, b, sign)
-	}
-
-	return
-}
-
-func parseDec10(str string) (n option.Option[Number]) {
-	next, sign := parseSign(str)
-
-	return setDec(next, 10, sign)
-}
-
-func parseDecN(str string) (n option.Option[Number]) {
-	next, sign := parseSignN(str)
-	next, base := parseBaseN(next)
-
-	return setDec(next, base, sign)
-}
-
-func parseExp(str string) (next string, baseExponent option.Option[int], exponent option.Option[int]) {
-	begin := strings.Index(str, "x")
-	end := strings.Index(str, "^")
-	if begin > end || begin < 0 || end < 0 {
-		return
-	}
-
-	sBase, sExponent := str[begin+1:end], str[end+1:]
-
-	if b, err := strconv.Atoi(sBase); err == nil && isBaseValid(b) {
-		if e, err := strconv.Atoi(sExponent); err == nil {
-			next, baseExponent, exponent = str[:begin], option.Some(b), option.Some(e)
-		}
-	}
-
-	return
-}
-
-func parseExp10(str string) (next string, exponent option.Option[int]) {
-	i := strings.Index(strings.ToLower(str), "e")
-	if i < 0 {
-		return
-	}
-
-	sExponent := str[i+1:]
-
-	if e, err := strconv.Atoi(sExponent); err == nil {
-		next, exponent = str[:i], option.Some(e)
-	}
-
-	return
-}
-
-func setSci(str string, base uint, sign, baseExponent, exponent int) (n option.Option[Number]) {
-	next, dot := parseDot(str)
-
-	if num, ok := parseNumber(next, base).Get(); ok {
-		denom := pow(base, dot)
-		nn := Number{
-			base: base,
-			tpe:  Scientific,
-			atom: entire0(num, sign).div(denom),
-		}
-		if exponent > 0 {
-			nn.atom = nn.atom.mul(pow(baseExponent, exponent))
-		} else if exponent < 0 {
-			nn.atom = nn.atom.div(pow(baseExponent, -exponent))
-		}
-
-		n = option.Some(nn.format())
-	}
-
-	return
-}
-
-func parseSci(str string) (n option.Option[Number]) {
-	next, base := parseBase(str)
-
-	if b, ok := base.Get(); ok {
-		next, sign := parseSign(next)
-		next, be, e := parseExp(next)
-		if baseExponent, ok := be.Get(); ok {
-			if exponent, ok := e.Get(); ok {
-				n = setSci(next, b, sign, baseExponent, exponent)
-			}
-		}
-	}
-
-	return
-}
-
-func parseSci10(str string) (n option.Option[Number]) {
-	next, sign := parseSign(str)
-	next, be, e := parseExp(next)
-
-	if baseExponent, ok := be.Get(); ok {
-		if exponent, ok := e.Get(); ok {
-			n = setSci(next, 10, sign, baseExponent, exponent)
-		}
-	}
-
-	return
-}
-
-func parseSci10Simple(str string) (n option.Option[Number]) {
-	next, sign := parseSign(str)
-	next, e := parseExp10(next)
-
-	if exponent, ok := e.Get(); ok {
-		n = setSci(next, 10, sign, 10, exponent)
+		next, sign := parseSignN(next)
+		n = setInt(next, b, sign)
 	}
 
 	return
 }
 
 // Parse retourne un nombre à partir d’une chaîne de caractères.
-func Parse(str string) option.Option[Number] {
+func Parse(str string) (out option.Option[Number]) {
 	switch str {
 	case "+∞", "<inf>", "<+inf>":
 		return option.Some(Inf())
@@ -447,33 +210,50 @@ func Parse(str string) option.Option[Number] {
 	}
 
 	switch {
-	case regInt.MatchString(str):
-		return parseInt(str)
 	case regInt10.MatchString(str):
 		return parseInt10(str)
-	case regInt2.MatchString(str), regInt8.MatchString(str), regInt16.MatchString(str):
+	case regIntB.MatchString(str):
+		return parseIntB(str)
+	case regIntN.MatchString(str):
 		return parseIntN(str)
-	case regFrac.MatchString(str):
-		return parseFrac(str)
-	case regFrac10.MatchString(str):
-		return parseFrac10(str)
 	case regDec.MatchString(str):
-		return parseInt(str)
-	case regDec10.MatchString(str):
-		return parseInt10(str)
-	case regDec2.MatchString(str), regDec8.MatchString(str), regDec16.MatchString(str):
-		return parseIntN(str)
-	case regSci.MatchString(str):
-		return parseSci(str)
-	case regSci10.MatchString(str):
-		return parseSci10(str)
-	case regSci10Simple.MatchString(str):
-		return parseSci10Simple(str)
+		l := len(str)
+		i := strings.Index(str, ".")
+		dot := l - 1 - i
+		str = fmt.Sprintf("%s%s", str[:i], str[i+1:])
+		if n, ok := Parse(str).Get(); ok {
+			out = option.Some(n.Div(pow(n.Base(), dot)).ToType(Decimal))
+		}
+	case regExp10.MatchString(str):
+		i := strings.Index(strings.ToLower(str), "e")
+		if exponent, err := strconv.Atoi(str[i+1:]); err == nil {
+			if n, ok := Parse(str[:i]).Get(); ok {
+				out = option.Some(n.Mul(pow(10, exponent)).ToType(Scientific))
+			}
+		}
+	case regExpN.MatchString(str):
+		i, j := strings.Index(str, "×"), strings.Index(str, "^")
+		if expBase, err := strconv.ParseUint(str[i+1:j], 10, 64); err == nil && isBaseValid(expBase) {
+			if exponent, err := strconv.Atoi(str[j+1:]); err == nil {
+				if n, ok := Parse(str[:i]).Get(); ok {
+					out = option.Some(n.Mul(pow(expBase, exponent)).ToType(Scientific))
+				}
+			}
+		}
+	case regFrac.MatchString(str):
+		i := strings.Index(str, "/")
+		num, denom := Parse(str[:i]), Parse(str[i:])
+		if n, ok := num.Get(); ok {
+			if d, ok := denom.Get(); ok {
+				out = option.Some(n.Div(d).ToType(Fraction))
+			}
+		}
 	}
 
-	return option.None[Number]()
+	return
 }
 
+// ParseBool retourne 1 si vrai, et 0 sinon.
 func ParseBool(b bool) Number {
 	if b {
 		return One()
@@ -481,6 +261,5 @@ func ParseBool(b bool) Number {
 	return Zero()
 }
 
-func ToBool(n Number) bool {
-	return !n.IsZero() && !n.IsNan()
-}
+// ToBool retourne vrai si le nombre n’est ni NaN ni 0.
+func ToBool(n Number) bool { return n.Sign() != 0 }
diff --git a/number/number.go b/number/number.go
index fde7a9b..320b2bc 100644
--- a/number/number.go
+++ b/number/number.go
@@ -1,5 +1,13 @@
 package number
 
+import (
+	"fmt"
+	"math/big"
+	"strings"
+
+	"gitea.zaclys.com/bvaudour/gob/option"
+)
+
 // NumberType représente le type d’un nombre.
 type NumberType uint
 
@@ -12,299 +20,585 @@ const (
 
 // Number représente un nombre.
 type Number struct {
-	atom
-	tpe  NumberType
-	base uint
+	number rat
+	sign   int
+	tpe    NumberType
+	base   uint
 }
 
-// Undefined retourne un nombre indéfini, signé :
-// - si sign < 0, retourne -∞
-// - si sign > 0, retourne +∞
-// - sinon, retourne NaN
-func Undefined(sign int) Number {
-	return Number{
-		base: 10,
-		tpe:  Integer,
-		atom: undefined(sign),
-	}
+func (n *Number) get() (r *big.Rat, ok bool) {
+	return n.number.Get()
 }
 
-// Nan retourne NaN.
-func Nan() Number { return Undefined(0) }
-
-// Inf retourne +∞.
-func Inf() Number { return Undefined(1) }
-
-// NegInf retourne -∞.
-func NegInf() Number { return Undefined(-1) }
-
-// Int retourne un nombre à partir d’un entier, et éventuellement une base.
-func Int[N integer](n N, base ...uint) Number {
-	return Number{
-		base: formatBase(base...),
-		tpe:  Integer,
-		atom: entire(n, 1),
+func (n *Number) rat() (r *big.Rat, ok bool) {
+	if r, ok := n.get(); ok {
+		r = new(big.Rat).Set(r)
+		if n.Sign() < 0 {
+			r = r.Neg(r)
+		}
 	}
+
+	return
 }
 
-// Zero retourne le nombre 0.
-func Zero(base ...uint) Number { return Int(0, base...) }
+func (n *Number) format() Number {
+	n.base, n.sign, n.tpe = formatBase(n.base), signOf(n.sign), min(n.tpe, Fraction)
 
-// One retourne le nombre 1.
-func One(base ...uint) Number { return Int(1, base...) }
-
-// Two retourne le nombre 2.
-func Two(base ...uint) Number { return Int(2, base...) }
-
-// Float retourne un nombre à partir d’un flottant, et éventuellement, une base.
-func Float[N ~float32 | ~float64](n N, base ...uint) Number {
-	return Number{
-		base: formatBase(base...),
-		tpe:  Decimal,
-		atom: decimal(n, 1),
-	}
-}
-
-// Frac retourne un nombre à partir du numérateur, du dénominateur, et éventuellement, une base.
-func Frac[N integer](num N, denom N, base ...uint) Number {
-	return Number{
-		base: formatBase(base...),
-		tpe:  Fraction,
-		atom: frac(num, denom, 1),
-	}
-}
-
-func (n Number) set(a atom, format ...bool) Number {
-	out := Number{
-		atom: a,
-		tpe:  n.tpe,
-		base: n.base,
-	}
-
-	return out.format(format...)
-}
-
-func (n *Number) format(formatAtom ...bool) Number {
-	if len(formatAtom) > 0 && formatAtom[0] {
-		n.atom.format()
-	}
-
-	n.base = formatBase(n.base)
-
-	if !n.IsDefined() {
-		n.base = 10
+	if nb, ok := n.get(); ok {
+		n.sign *= nb.Sign()
+		if n.tpe == Integer && !nb.IsInt() {
+			num, denom := nb.Num(), nb.Denom()
+			nb.SetInt(num.Quo(num, denom))
+		}
+		nb.Abs(nb)
+	} else {
 		n.tpe = Integer
-	} else if n.tpe == Integer && !n.isInt() {
-		n.setInt()
 	}
 
 	return *n
 }
 
-func (n Number) clone(format ...bool) Number {
+func (n Number) set(r *big.Rat, tpe NumberType, sign ...int) Number {
+	s := 1
+	if len(sign) > 0 {
+		s = sign[0]
+	}
 	out := Number{
-		atom: n.atom.clone(format...),
+		base:   n.Base(),
+		tpe:    tpe,
+		sign:   s,
+		number: option.Some(r),
+	}
+
+	return out.format()
+}
+
+// Clone crée une copie profonde du nombre.
+func (n Number) Clone() Number {
+	out := Number{
+		sign: n.sign,
 		tpe:  n.tpe,
 		base: n.base,
 	}
 
-	if len(format) > 0 && format[0] {
-		return out.format()
+	if nb, ok := n.get(); ok {
+		out.number = option.Some(new(big.Rat).Set(nb))
 	}
+
 	return out
 }
 
-// Type retourne le type de nombre.
-func (n Number) Type() NumberType {
-	return n.tpe
-}
+// Base retourne la base utilisée pour l’affichage du nombre.
+func (n Number) Base() uint { return n.base }
 
-// ToType convertit le nombre au type donné.
-func (n Number) ToType(t NumberType) Number {
-	out := n.clone()
-	switch t {
-	case Integer, Decimal, Fraction, Scientific:
-		out.tpe = t
-	default:
-		out.tpe = Decimal
-	}
+// Type retourne le type de nombre (entier, décimal, fraction ou scientifique).
+func (n Number) Type() NumberType { return n.tpe }
 
-	return out.format(true)
-}
-
-// Base retourne la base du nombre.
-func (n Number) Base() uint {
-	return n.base
-}
+// Sign retourne :
+// - 0 si n = 0 ou NaN
+// - 1 si n > 0
+// - -1 si n < 0
+func (n Number) Sign() int { return n.sign }
 
 // ToBase convertit le nombre dans la base donnée.
 func (n Number) ToBase(base uint) Number {
-	out := n.clone(true)
+	out := n.Clone()
 	out.base = formatBase(base)
 
 	return out
 }
 
-// Neg retourne -n.
-func (n Number) Neg() Number {
-	return n.set(n.neg())
+// ToType convertit le nombre dans le type donné. La base est conservée, sauf si une base est fournie.
+func (n Number) ToType(tpe NumberType, base ...uint) Number {
+	out := n.Clone()
+	out.tpe = tpe
+	out = out.format()
+
+	if len(base) > 0 {
+		return out.ToBase(base[0])
+	}
+	return out
 }
 
-// Abs retourne |n|.
-func (n Number) Abs() Number {
-	return n.set(n.abs())
-}
+// IsDefined retourne vrai si le nombre est défini.
+func (n Number) IsDefined() bool { return n.number.IsDefined() }
 
 // IsInt retourne vrai si le nombre est entier.
 func (n Number) IsInt() bool {
-	return n.isInt()
+	nb, ok := n.get()
+
+	return ok && nb.IsInt()
+}
+
+// IsInt64 retourne vrai si le nombre est convertible en int64.
+func (n Number) IsInt64() bool {
+	nb, ok := n.get()
+
+	return ok && nb.IsInt() && nb.Num().IsInt64()
+}
+
+// IsUint64 retourne vrai si le nombre est convertible en uint64.
+func (n Number) IsUint64() bool {
+	nb, ok := n.get()
+
+	return ok && nb.IsInt() && nb.Num().IsUint64()
+}
+
+// Is retourne vrai si n = i.
+func (n Number) Is(i int64) bool {
+	if nb, ok := n.get(); ok && nb.IsInt() {
+		num := nb.Num()
+		return num.IsInt64() && num.Int64() == i
+	}
+
+	return false
+}
+
+// IsUint retourne vrai si n = u.
+func (n Number) IsUint(u uint64) bool {
+	if nb, ok := n.get(); ok && nb.IsInt() {
+		num := nb.Num()
+		return num.IsUint64() && num.Uint64() == u
+	}
+
+	return false
+}
+
+// IsFloat retourne vrai si n = f.
+func (n Number) IsFloat(f float64) bool {
+	if nb, ok := n.get(); ok {
+		nf, ok := nb.Float64()
+		return nf == f && ok
+	}
+
+	return false
+}
+
+// IsNeg retourne vrai si n < 0.
+func (n Number) IsNeg() bool { return n.Sign() < 0 }
+
+// IsPos retourne vrai si n > 0.
+func (n Number) IsPos() bool { return !n.IsNeg() }
+
+// IsZero retourne vrai si n = 0.
+func (n Number) IsZero() bool { return n.IsDefined() && n.Sign() == 0 }
+
+// IsInf retourne vrai si n = +∞.
+func (n Number) IsInf() bool { return !n.IsDefined() && n.Sign() > 0 }
+
+// IsNegInf retourne vrai si n = -∞.
+func (n Number) IsNegInf() bool { return !n.IsDefined() && n.Sign() < 0 }
+
+// IsNan retourne vrai si n = NaN.
+func (n Number) IsNan() bool { return !n.IsDefined() && n.Sign() == 0 }
+
+// ToInt64 retourne le nombre converti en int64, et vrai si la conversion a réussi.
+func (n Number) ToInt64() (i int64, ok bool) {
+	var nb *big.Rat
+	if nb, ok = n.get(); ok {
+		if ok = nb.IsInt(); ok {
+			num := nb.Num()
+			if ok = num.IsInt64(); ok {
+				i = num.Int64()
+			}
+		}
+	}
+
+	return
+}
+
+// ToUint64 retourne le nombre converti en uint64, et vrai si la conversion a réussi.
+func (n Number) ToUint64() (u uint64, ok bool) {
+	var nb *big.Rat
+	if nb, ok = n.get(); ok {
+		if ok = nb.IsInt(); ok {
+			num := nb.Num()
+			if ok = num.IsUint64(); ok {
+				u = num.Uint64()
+			}
+		}
+	}
+
+	return
+}
+
+// IsEven retourne vrai si n est entier et pair.
+func (n Number) IsEven() bool {
+	if nb, ok := n.get(); ok {
+		return nb.IsInt() && nb.Num().Bit(0) == 0
+	}
+
+	return false
+}
+
+// IsOdd retourne vrai si n est entier et impair.
+func (n Number) IsOdd() bool {
+	if nb, ok := n.get(); ok {
+		return nb.IsInt() && nb.Num().Bit(0) != 0
+	}
+
+	return false
 }
 
 // Num retourne le numérateur.
 func (n Number) Num() Number {
-	out := Number{
-		atom: n.num(),
-		base: n.base,
-		tpe:  Integer,
+	if n.Sign() == 0 {
+		return IntOf(0, n.Base())
+	} else if nb, ok := n.rat(); ok {
+		return IntOf0(nb.Num(), n.Base())
 	}
 
-	return out.format()
+	return IntOf(n.Sign(), n.Base())
 }
 
 // Denom retourne le dénominateur.
 func (n Number) Denom() Number {
-	out := Number{
-		atom: n.denom(),
-		base: n.base,
-		tpe:  Integer,
+	if nb, ok := n.get(); ok {
+		return IntOf0(nb.Denom(), n.Base())
 	}
 
-	return out.format()
+	return IntOf(0, n.Base())
 }
 
-// Num retourne le numérateur et le dénominateur.
-func (n Number) NumDenom() (Number, Number) {
-	return n.Num(), n.Denom()
+// NumDenom retourne le numérateur et le dénominateur.
+func (n Number) NumDenom() (Number, Number) { return n.Num(), n.Denom() }
+
+// Neg retourne -n.
+func (n Number) Neg() Number {
+	out := n.Clone()
+	out.sign = -out.sign
+
+	return out
+}
+
+// Abs retourne |n|.
+func (n Number) Abs() Number {
+	out := n.Clone()
+	out.sign = abs(out.sign)
+
+	return out
 }
 
 // Cmp retourne :
+// - 1 si n1 > n2
 // - -1 si n1 < n2
-// - +1 si n1 > n2
-// - 0 sinon.
+// - 0 si n1 = n2
+// - 2 ou -2 si les nombres ne sont pas comparables (ie. n1 = NaN ou n2 = NaN)
 func (n1 Number) Cmp(n2 Number) int {
-	return n1.cmp(n2.atom)
+	if n1.IsNan() {
+		if n2.IsNan() {
+			return 0
+		}
+		return -2
+	} else if n2.IsNan() {
+		return 2
+	} else if nb1, ok := n1.rat(); ok {
+		if nb2, ok := n2.rat(); ok {
+			return nb1.Cmp(nb2)
+		}
+		return -n2.Sign()
+	} else if n2.IsDefined() {
+		return n1.Sign()
+	}
+
+	return compare(n1.Sign(), n2.Sign())
 }
 
+// Eq retourne vrai si n1 = n2.
 func (n1 Number) Eq(n2 Number) bool { return n1.Cmp(n2) == 0 }
+
+// Ne retourne vrai si n1 ≠ n2.
 func (n1 Number) Ne(n2 Number) bool { return n1.Cmp(n2) != 0 }
+
+// Gt retourne vrai si n1 > n2.
 func (n1 Number) Gt(n2 Number) bool { return n1.Cmp(n2) > 0 }
+
+// Lt retourne vrai si n1 < n2.
 func (n1 Number) Lt(n2 Number) bool { return n1.Cmp(n2) < 0 }
+
+// Ge retourne vrai si n1 ≥ n2.
 func (n1 Number) Ge(n2 Number) bool { return n1.Cmp(n2) >= 0 }
+
+// Le retourne vrai si n1 ≤ n2.
 func (n1 Number) Le(n2 Number) bool { return n1.Cmp(n2) <= 0 }
 
 // Add retourne n1 + n2.
 func (n1 Number) Add(n2 Number) Number {
-	out := Number{
-		base: n1.base,
-		tpe:  max(n1.tpe, n2.tpe),
-		atom: n1.add(n2.atom),
+	if r1, ok := n1.rat(); ok {
+		if r2, ok := n2.rat(); ok {
+			return n1.set(new(big.Rat).Add(r1, r2), max(n1.Type(), n2.Type()))
+		}
+		return n2.Clone()
+	} else if n2.IsDefined() || n1.Sign() == n2.Sign() {
+		return Undefined(n1.Sign())
 	}
 
-	return out.format()
+	return Nan()
 }
 
-// Sub retourne n1 - n2.
-func (n1 Number) Sub(n2 Number) Number {
-	out := Number{
-		base: n1.base,
-		tpe:  max(n1.tpe, n2.tpe),
-		atom: n1.sub(n2.atom),
-	}
-
-	return out.format()
-}
+// Sub retourne n1 − n2.
+func (n1 Number) Sub(n2 Number) Number { return n1.Add(n2.Neg()) }
 
 // Inc retourne n + 1.
-func (n Number) Inc() Number {
-	return n.Add(One())
-}
+func (n Number) Inc() Number { return n.Add(One()) }
 
 // Dec retourne n − 1.
-func (n Number) Dec() Number {
-	return n.Sub(One())
-}
+func (n Number) Dec() Number { return n.Sub(One()) }
 
 // Mul retourne n1 × n2.
 func (n1 Number) Mul(n2 Number) Number {
-	out := Number{
-		base: n1.base,
-		tpe:  max(n1.tpe, n2.tpe),
-		atom: n1.mul(n2.atom),
+	s := n1.Sign() * n2.Sign()
+	if nb1, ok := n1.get(); ok {
+		if nb2, ok := n2.get(); ok {
+			return n1.set(new(big.Rat).Mul(nb1, nb2), max(n1.Type(), n2.Type()), s)
+		}
 	}
 
-	return out.format()
+	return Undefined(s)
 }
 
-// Div retourne n1 ÷ n2 (division exacte).
+// Div retourne n1 / n2 (division exacte).
 func (n1 Number) Div(n2 Number) Number {
-	out := Number{
-		base: n1.base,
-		tpe:  max(n1.tpe, n2.tpe),
-		atom: n1.div(n2.atom),
+	s := n1.Sign() * n2.Sign()
+	if nb1, ok := n1.get(); ok {
+		if nb2, ok := n2.get(); ok {
+			if nb2.IsInt() && nb2.Num().IsInt64() && nb2.Num().Int64() == 0 {
+				return Nan()
+			}
+
+			t := max(n1.Type(), n2.Type())
+			result := new(big.Rat).Quo(nb1, nb2)
+			if t == Integer && !result.IsInt() {
+				t = Decimal
+			}
+
+			return n1.set(result, t, s)
+		}
+
+		return Undefined(s)
+	} else if n2.IsDefined() {
+		return Undefined(s)
 	}
 
-	return out.format()
+	return Nan()
 }
 
+// inv retourne 1/n.
+func (n Number) Inv() Number { return IntOf(1, n.Base()).Div(n) }
+
 // Quo retourne n1 ÷ n2 (division entière).
 func (n1 Number) Quo(n2 Number) Number {
-	out := Number{
-		base: n1.base,
-		tpe:  Integer,
-		atom: n1.quo(n2.atom),
+	if nb1, ok := n1.rat(); ok {
+		if nb2, ok := n2.rat(); ok {
+			if nb2.IsInt() && nb2.Num().IsInt64() && nb2.Num().Int64() == 0 {
+				return Nan()
+			}
+
+			q := new(big.Rat).Quo(nb1, nb2)
+			return IntOf0(new(big.Int).Quo(q.Num(), q.Denom()), n1.Base())
+		}
+
+		return Undefined(n1.Sign() * n2.Sign())
+	} else if n2.IsDefined() {
+		return Undefined(n1.Sign() * n2.Sign())
 	}
 
-	return out.format()
+	return Nan()
+}
+
+// QuoRem retourne q et r tels que n1 = q×n2 + r où q est entier.
+func (n1 Number) QuoRem(n2 Number) (q, r Number) {
+	q = n1.Quo(n2)
+	r = n1.Sub(n2.Mul(q))
+
+	return
 }
 
 // Rem retourne n1 % n2.
 func (n1 Number) Rem(n2 Number) Number {
-	out := Number{
-		base: n1.base,
-		tpe:  max(n1.tpe, n2.tpe),
-		atom: n1.rem(n2.atom),
-	}
+	_, r := n1.QuoRem(n2)
 
-	return out.format()
+	return r
 }
 
-// QuoRem retourne la division entière et le reste.
-func (n1 Number) QuoRem(n2 Number) (q, r Number) {
-	q.base, r.base = n1.base, n1.base
-	q.tpe, r.tpe = Integer, max(n1.tpe, n2.tpe)
-	q.atom, r.atom = n1.quoRem(n2.atom)
+func (n Number) pow(p int64) (out Number) {
+	inv := p < 0
+	p = abs(p)
 
-	return q.format(), r.format()
+	switch {
+	case p == 0:
+		if n.IsNan() {
+			return Nan()
+		}
+		return IntOf(1, n.Base())
+	case p == 1:
+		out = n.Clone()
+	case p == 2:
+		out = n.Square()
+	case p&1 == 0:
+		out = n.Square().pow(p >> 1)
+	default:
+		out = n.Square().pow(p >> 1).Mul(n)
+	}
+
+	if inv {
+		out = out.Inv()
+	}
+	return
+}
+func (n Number) optimize(precision Number) (out Number) {
+	out = n
+	if n.Denom().Gt(precision) {
+		out = n.Num().Mul(precision).Quo(n.Denom()).Div(precision).ToType(n.Type())
+	}
+
+	return
+}
+func (n Number) sqrt(s uint64) (out Number) {
+	if n.IsNan() || s < 2 || (s&1 == 0 && n.IsNeg()) {
+		return Nan()
+	} else if !n.IsDefined() {
+		return n.Clone()
+	}
+
+	s0 := IntOf(s)
+	s1 := s0.Dec()
+	precision := pow[uint, uint](n.Base())
+	deltaMax := precision.Inv()
+	heron := func(partial Number) Number {
+		return ((partial.Mul(s1)).Add(n.Div(partial.pow(int64(s - 1))))).Div(s0).optimize(precision)
+	}
+
+	out = n
+	for {
+		tmp := heron(out)
+		if out.Eq(tmp) {
+			break
+		} else if (tmp.Sub(out)).Abs().Lt(deltaMax) {
+			out = tmp
+			break
+		}
+		out = tmp
+	}
+
+	if n.Type() == Integer && out.IsInt() {
+		out = out.ToType(Integer)
+	}
+
+	return
 }
 
-// Inv retourne 1 ÷ n.
-func (n Number) Inv() Number {
-	t := n.tpe
-	if t == Integer {
-		t = Fraction
+// Pow retourne n1 ^ n2.
+func (n1 Number) Pow(n2 Number) Number {
+	if !n2.IsDefined() {
+		return Nan()
 	}
 
-	out := Number{
-		tpe:  t,
-		base: n.base,
-		atom: n.inv(),
+	p2, s2 := n2.NumDenom()
+	p, pok := p2.ToInt64()
+	s, sok := s2.ToUint64()
+	if !pok || !sok {
+		return Nan()
 	}
 
-	if n.tpe == Integer && out.IsInt() {
-		out.tpe = Integer
+	out := n1.pow(p)
+	if s > 1 {
+		out = out.sqrt(s)
 	}
 
-	return out.format()
+	return out
+}
+
+// Square retourne n².
+func (n Number) Square() Number { return n.Mul(n) }
+
+// Sqrtn retourne la racine n2ième de n1.
+func (n1 Number) Sqrtn(n2 Number) Number {
+	s, ok := n2.ToUint64()
+
+	if !ok {
+		return Nan()
+	}
+	return n1.sqrt(s)
+}
+
+// Sqrt retourne la racine carrée de n.
+func (n Number) Sqrt() Number { return n.Sqrtn(Two()) }
+
+func (n Number) lsh(s uint64) Number {
+	if nb, ok := n.rat(); ok {
+		num, denom := nb.Num(), nb.Denom()
+		return FracOf0(new(big.Int).Lsh(num, uint(s)), denom, n.Base()).ToType(n.Type())
+	}
+
+	return n.Clone()
+}
+func (n Number) rsh(s uint64) Number {
+	if nb, ok := n.rat(); ok {
+		t := n.Type()
+		if t == Integer {
+			return IntOf0(new(big.Int).Rsh(nb.Num(), uint(s)), n.Base())
+		}
+		return FracOf0(nb.Num(), new(big.Int).Lsh(nb.Denom(), uint(s)), n.Base()).ToType(t)
+	}
+
+	return n.Clone()
+}
+
+// Lsh retourne n1 << n2.
+func (n1 Number) Lsh(n2 Number) Number {
+	if s, ok := n2.ToUint64(); ok {
+		return n1.lsh(s)
+	}
+
+	return Nan()
+}
+
+// Rsh retourne n1 >> n2.
+func (n1 Number) Rsh(n2 Number) Number {
+	if s, ok := n2.ToUint64(); ok {
+		return n1.rsh(s)
+	}
+
+	return Nan()
+}
+
+// Len retourne le nombre de chiffre de n si n est entier ou -1 sinon.
+func (n Number) Len() int {
+	if nb, ok := n.get(); ok {
+		if !nb.IsInt() {
+			return -1
+		}
+		num := nb.Num()
+		if num.IsInt64() && num.Int64() == 0 {
+			return 1
+		}
+		s := num.Text(int(n.Base()))
+		return len(s)
+	}
+
+	return -1
+}
+
+// Bit retourne le n2ième chiffre de n1 si n est entier, ou -1 sinon.
+// Le n° de bit commence à 0 à partir de la droite.
+func (n1 Number) Bit(n2 Number) int {
+	b, ok := n2.ToUint64()
+	if !ok || !n1.IsInt() {
+		return -1
+	}
+
+	out := n1
+	if b > 0 {
+		out = n1.Quo(pow(n1.Base(), b))
+	}
+
+	out = out.Rem(IntOf(n1.Base()))
+	if result, ok := out.ToInt64(); ok {
+		return int(result)
+	}
+
+	return -1
 }
 
 // Fact retourne n!.
@@ -315,7 +609,7 @@ func (n Number) Fact() Number {
 	case !n.IsInt() || n.IsNeg():
 		return Nan()
 	default:
-		out := One(n.base)
+		out := One(n.Base())
 		for e := Two(); e.Le(n); e = e.Inc() {
 			out.Mul(e)
 		}
@@ -323,104 +617,135 @@ func (n Number) Fact() Number {
 	}
 }
 
-// Lsh retourne n1 << n2.
-func (n1 Number) Lsh(n2 Number) Number {
-	if n2.IsNeg() {
-		return n1.Rsh(n2.Abs())
+func (n Number) text() string {
+	if nb, ok := n.get(); ok {
+		return nb.Num().Text(int(n.Base()))
 	}
-
-	if n, ok := n2.toInt64(); ok && n >= 0 {
-		return n1.set(n1.lsh(uint(n)), true)
-	}
-	return Nan()
+	return ""
 }
-
-// Rsh retourne n1 << n2.
-func (n1 Number) Rsh(n2 Number) Number {
-	if n2.IsNeg() {
-		return n1.Lsh(n2.Abs())
+func (n Number) undefinedString() string {
+	switch n.Sign() {
+	case -1:
+		return "-∞"
+	case +1:
+		return "+∞"
+	default:
+		return "NaN"
 	}
-
-	if n, ok := n2.toInt64(); ok && n >= 0 {
-		return n1.set(n1.rsh(uint(n)), true)
-	}
-	return Nan()
 }
+func (n Number) intString() (out string) {
+	out = n.text()
 
-// Len retourne le nombre de chiffre d’un nombre entier (ou -1 s’il n’est pas entier)
-func (n Number) Len() int {
-	return n.len(n.base)
-}
-
-// Bit retourne le chiffre à la position n2 (en partant de 0)
-// d’un nombre entier (ou -1 si n1 ou n2 n’est pas entier).
-func (n1 Number) Bit(n2 Number) int {
-	if n, ok := n2.toInt64(); ok && n >= 0 {
-		return n1.bit(uint64(n), n1.base)
+	if n.Sign() < 0 {
+		out = fmt.Sprintf("-%s", out)
 	}
 
-	return -1
-}
-
-// Pow retourne n1 ^ n2.
-func (n1 Number) Pow(n2 Number) Number {
-	if !n2.IsDefined() {
-		return Nan()
+	if base := n.Base(); base != 10 {
+		out = fmt.Sprintf("(%d)%s", base, out)
 	}
 
-	p, s := n2.NumDenom()
-	if !p.isInt64() || !s.isInt64() {
-		n2 = n2.set(n2.optimize(pow(n2.base, FloatingPrecision)))
-		p, s = n2.NumDenom()
-		if !p.isInt64() || !s.isInt64() {
-			return Nan()
+	return
+}
+func (n Number) fracString() string {
+	num, denom := n.NumDenom()
+
+	return fmt.Sprintf("%s/%s", num.intString(), denom.intString())
+}
+func (n Number) decString() (out string) {
+	base, sign := n.Base(), n.Sign()
+	num, denom := n.NumDenom()
+	precision := pow[uint, uint](base)
+
+	num = num.Abs().Mul(precision)
+	q := num.Quo(denom)
+
+	out = "0"
+	if num.Ge(denom) {
+		out = q.text()
+	}
+
+	p := int(FloatingPrecision)
+	if len(out) < p {
+		out = fmt.Sprintf("%s%s", strings.Repeat("0", p), out)
+	}
+
+	dot := len(out) - p
+	out = fmt.Sprintf("%s.%s", out[:dot], out[dot:])
+
+	if !FixedPrecision {
+		l := len(out) - 1
+		for out[l] == '0' {
+			out, l = out[:l], l-1
+		}
+		if out == "." {
+			out = "0."
 		}
 	}
 
-	if p0, ok := p.toInt64(); ok {
-		if s0, ok := s.toInt64(); ok && s0 > 0 {
-			inv := p0 < 0
-			if inv {
-				p0 = -p0
-			}
-			out := Number{
-				tpe:  n1.tpe,
-				base: n1.base,
-				atom: n1.pow(uint64(p0)).sqrtn(uint64(s0), n1.base),
-			}
-			if inv {
-				out.atom = out.atom.inv()
-			}
-			if n1.tpe == Integer && !out.isInt() {
-				out.tpe = Decimal
-			}
-
-			return out.format()
-		}
+	if sign < 0 {
+		out = fmt.Sprintf("-%s", out)
+	} else if q.IsZero() && sign > 0 {
+		out = fmt.Sprintf("+%s", out)
 	}
 
-	return Nan()
-}
-
-// Sqrtn retourne la racine n2ième de n1.
-func (n1 Number) Sqrtn(n2 Number) Number {
-	if n, ok := n2.toInt64(); ok && n > 0 {
-		out := Number{
-			tpe:  n1.tpe,
-			base: n1.base,
-			atom: n1.sqrtn(uint64(n), n1.base),
-		}
-		if n1.tpe == Integer && !out.isInt() {
-			out.tpe = Decimal
-		}
-
-		return out.format()
+	if base != 10 {
+		out = fmt.Sprintf("(%d)%s", base, out)
 	}
 
-	return Nan()
+	return
+}
+func (n Number) sciString() (out string) {
+	base, sign := n.Base(), n.Sign()
+	var exponent int
+	tmp := n
+	if !n.IsZero() {
+		num, denom := n.Abs().NumDenom()
+		nl, dl := num.Len(), denom.Len()
+		exponent = nl - dl
+		nBase := IntOf(base)
+		if exponent > 0 {
+			denom = denom.Mul(nBase.pow(int64(exponent)))
+		} else if exponent < 0 {
+			num = num.Mul(nBase.pow(int64(-exponent)))
+		}
+
+		if num.Lt(denom) {
+			exponent--
+			num = num.Mul(nBase)
+		}
+		tmp = num.Div(denom)
+	}
+
+	if sign < 0 {
+		tmp = tmp.Neg()
+	}
+
+	signExponent := ""
+	if exponent > 0 {
+		signExponent = "+"
+	}
+
+	out = tmp.decString()
+	if base == 10 {
+		return fmt.Sprintf("%sE%s%d", out, signExponent, exponent)
+	}
+	return fmt.Sprintf("%s×%d^%s%d", out, base, signExponent, exponent)
 }
 
-// Sqrt retourne la racine carrée de n.
-func (n Number) Sqrt() Number {
-	return n.Sqrtn(Int(2))
+// String retourne la représentation du nombre sous forme de chaîne de caractères.
+func (n Number) String() string {
+	if !n.IsDefined() {
+		return n.undefinedString()
+	}
+
+	switch n.Type() {
+	case Integer:
+		return n.intString()
+	case Fraction:
+		return n.fracString()
+	case Scientific:
+		return n.sciString()
+	default:
+		return n.decString()
+	}
 }
diff --git a/number/operations.go b/number/operations.go
index fb7da44..a30f415 100644
--- a/number/operations.go
+++ b/number/operations.go
@@ -11,6 +11,7 @@ type Op2To2Func func(Number, Number) (Number, Number)
 type ReduceFunc func(...Number) Number
 type MapFunc func(...Number) []Number
 
+// ToBase convertit n selon la base donnée.
 func ToBase[N integer](n Number, base N) Number {
 	return n.ToBase(formatBase(base))
 }
@@ -24,36 +25,33 @@ func toType[N integer](n Number, t NumberType, base ...N) Number {
 	return n
 }
 
-func ToInteger[N integer](n Number, base ...N) Number {
-	return toType(n, Integer, base...)
-}
+// ToInteger convertit n en entier.
+func ToInteger[N integer](n Number, base ...N) Number { return toType(n, Integer, base...) }
 
-func ToDecimal[N integer](n Number, base ...N) Number {
-	return toType(n, Decimal, base...)
-}
+// ToDecimal convertit n en décimal.
+func ToDecimal[N integer](n Number, base ...N) Number { return toType(n, Decimal, base...) }
 
-func ToFraction[N integer](n Number, base ...N) Number {
-	return toType(n, Fraction, base...)
-}
+// ToFraction convertit n en fraction.
+func ToFraction[N integer](n Number, base ...N) Number { return toType(n, Fraction, base...) }
 
-func ToScientific[N integer](n Number, base ...N) Number {
-	return toType(n, Scientific, base...)
-}
+// ToScientific convertit n en nombre scientifique.
+func ToScientific[N integer](n Number, base ...N) Number { return toType(n, Scientific, base...) }
 
 // Fonctions de type f(n) → n
-func Neg(n Number) Number   { return n.Neg() }
-func Abs(n Number) Number   { return n.Abs() }
-func Num(n Number) Number   { return n.Num() }
-func Denom(n Number) Number { return n.Denom() }
-func Inc(n Number) Number   { return n.Inc() }
-func Dec(n Number) Number   { return n.Dec() }
-func Inv(n Number) Number   { return n.Inv() }
-func Fact(n Number) Number  { return n.Fact() }
-func Len(n Number) Number   { return Int(n.Len()) }
-func Sqrt(n Number) Number  { return n.Sqrt() }
+func Neg(n Number) Number    { return n.Neg() }
+func Abs(n Number) Number    { return n.Abs() }
+func Num(n Number) Number    { return n.Num() }
+func Denom(n Number) Number  { return n.Denom() }
+func Inc(n Number) Number    { return n.Inc() }
+func Dec(n Number) Number    { return n.Dec() }
+func Inv(n Number) Number    { return n.Inv() }
+func Fact(n Number) Number   { return n.Fact() }
+func Len(n Number) Number    { return IntOf(n.Len()) }
+func Sqrt(n Number) Number   { return n.Sqrt() }
+func Square(n Number) Number { return n.Square() }
 
 // Fonctions de type f(n, n) → n
-func Cmp(n1, n2 Number) Number   { return Int(n1.Cmp(n2)) }
+func Cmp(n1, n2 Number) Number   { return IntOf(n1.Cmp(n2)) }
 func Eq(n1, n2 Number) Number    { return ParseBool(n1.Eq(n2)) }
 func Ne(n1, n2 Number) Number    { return ParseBool(n1.Ne(n2)) }
 func Gt(n1, n2 Number) Number    { return ParseBool(n1.Gt(n2)) }
@@ -68,7 +66,7 @@ func Quo(n1, n2 Number) Number   { return n1.Quo(n2) }
 func Rem(n1, n2 Number) Number   { return n1.Rem(n2) }
 func Lsh(n1, n2 Number) Number   { return n1.Lsh(n2) }
 func Rsh(n1, n2 Number) Number   { return n1.Rsh(n2) }
-func Bit(n1, n2 Number) Number   { return Int(n1.Bit(n2)) }
+func Bit(n1, n2 Number) Number   { return IntOf(n1.Bit(n2)) }
 func Pow(n1, n2 Number) Number   { return n1.Pow(n2) }
 func Sqrtn(n1, n2 Number) Number { return n1.Sqrtn(n2) }
 
@@ -105,6 +103,7 @@ func Reduce(callback Op2Func) ReduceFunc {
 	}
 }
 
+// Max retourne le nombre le plus grand de la liste.
 func Max(numbers ...Number) (n Number) {
 	return Reduce(func(n1, n2 Number) Number {
 		if n2.Gt(n1) {
@@ -114,6 +113,7 @@ func Max(numbers ...Number) (n Number) {
 	})(numbers...)
 }
 
+// Min retourne le nombre le plus petit de la liste.
 func Min(numbers ...Number) (n Number) {
 	return Reduce(func(n1, n2 Number) Number {
 		if n2.Lt(n1) {
@@ -123,35 +123,100 @@ func Min(numbers ...Number) (n Number) {
 	})(numbers...)
 }
 
-func Sum(numbers ...Number) (n Number) {
-	return Reduce(Add)(numbers...)
-}
+// Sum retourne la somme des nombres.
+func Sum(numbers ...Number) (n Number) { return Reduce(Add)(numbers...) }
 
+// Mean retourne la moyenne des nombres.
 func Mean(numbers ...Number) (n Number) {
 	l := len(numbers)
 	if l == 0 {
 		return Nan()
 	}
 
-	return Sum(numbers...).Div(Int(l))
+	return Sum(numbers...).Div(IntOf(l))
 }
 
+// Median retourne la médiane des nombres.
+func Median(numbers ...Number) Number {
+	l := len(numbers)
+	if l == 0 {
+		return Nan()
+	}
+
+	numbers = Sort(numbers...)
+	if l&1 == 0 {
+		i := l >> 1
+		return numbers[i].Add(numbers[i-1]).Div(Two())
+	}
+
+	return numbers[l>>1]
+}
+
+// Mode retourne retourne le mode des nombres (ie. le nombre le plus fréquent).
+func Mode(numbers ...Number) Number {
+	l := len(numbers)
+	if l == 0 {
+		return Nan()
+	}
+
+	m := make(map[Number]int)
+loop:
+	for _, n := range numbers {
+		for k := range m {
+			if k.Eq(n) {
+				m[k]++
+				continue loop
+			}
+		}
+		m[n] = 1
+	}
+
+	i := 0
+	var n Number
+	for k, j := range m {
+		if j > i {
+			n, i = k, j
+		}
+	}
+
+	return n
+}
+
+// Variance retourne la variance des nombres.
+func Variance(numbers ...Number) Number {
+	m := Mean(numbers...)
+	if m.IsNan() {
+		return m
+	}
+
+	numbers = Map(func(n Number) Number {
+		return n.Sub(m).Square()
+	})(numbers...)
+
+	return Mean(numbers...)
+}
+
+// StdDeviation retourne l’écart-type des nombres.
+func StdDeviation(numbers ...Number) Number { return Variance(numbers...).Sqrt() }
+
+// Round arrondit le n selon la précision et la base données.
 func Round(n Number, precision uint64, base ...uint) Number {
 	if !n.IsDefined() || n.Type() == Integer {
 		return n
 	}
 
-	p := Number{
-		base: n.Base(),
-		tpe:  n.Type(),
-		atom: pow(formatBase(base...), precision),
+	b := n.Base()
+	if len(base) > 0 {
+		b = formatBase(base...)
 	}
-	p.format()
+
+	p := pow(b, precision)
 	num, denom := n.Num().Mul(p), n.Denom()
 
-	return num.Quo(denom).Div(p)
+	return num.Quo(denom).Div(p).ToType(n.Type())
 }
 
+// Reverse inverse l’ordre de la liste des nombres.
 func Reverse(numbers ...Number) []Number {
 	l := len(numbers)
 	for i := 0; i < l>>1; i++ {
@@ -162,6 +227,7 @@ func Reverse(numbers ...Number) []Number {
 	return numbers
 }
 
+// Sort trie les nombres par ordre croissant.
 func Sort(numbers ...Number) []Number {
 	sort.Slice(numbers, func(i, j int) bool {
 		return numbers[i].Lt(numbers[j])
@@ -170,6 +236,7 @@ func Sort(numbers ...Number) []Number {
 	return numbers
 }
 
+// SortDesc trie les nombres par ordre décroissant.
 func SortDesc(numbers ...Number) []Number {
 	sort.Slice(numbers, func(i, j int) bool {
 		return numbers[i].Gt(numbers[j])
diff --git a/number/util.go b/number/util.go
index 219f2b2..127baf1 100644
--- a/number/util.go
+++ b/number/util.go
@@ -1,5 +1,11 @@
 package number
 
+import (
+	"math/big"
+
+	"gitea.zaclys.com/bvaudour/gob/option"
+)
+
 type integer interface {
 	~int | ~int8 | ~int16 | ~int32 | ~int64 | ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
 }
@@ -8,6 +14,8 @@ type float interface {
 	~float32 | ~float64
 }
 
+type rat = option.Option[*big.Rat]
+
 func signOf[N integer | float](n N) int {
 	switch {
 	case n < 0:
@@ -19,6 +27,14 @@ func signOf[N integer | float](n N) int {
 	}
 }
 
+func abs[N integer | float](n N) N {
+	if n < 0 {
+		return -n
+	}
+
+	return n
+}
+
 func compare[N integer | float](n1, n2 N) int {
 	return signOf(n1 - n2)
 }
diff --git a/option/result.go b/option/result.go
index ba63397..a6f62e1 100644
--- a/option/result.go
+++ b/option/result.go
@@ -1,5 +1,9 @@
 package option
 
+import (
+	"fmt"
+)
+
 // Result stocke un résultat :
 // - soit le résultat est valide, et une valeur est stockée,
 // - soit le résultat est invalide, et une erreur est stockée.
@@ -41,3 +45,11 @@ func (r Result[T]) Err() (err error, ok bool) {
 func (r Result[T]) IsOk() bool {
 	return r.ok
 }
+
+func (r Result[T]) String() string {
+	return fmt.Sprintf(`{
+  value: %v,
+  error: %s,
+  ok: %v,
+	}`, r.v, r.err, r.ok)
+}
diff --git a/shell/console/atom/input.go b/shell/console/atom/input.go
index fbf1d1b..c686177 100644
--- a/shell/console/atom/input.go
+++ b/shell/console/atom/input.go
@@ -56,11 +56,8 @@ func (in *input) restart() {
 			n := in.readRune()
 			next <- n
 
-			needClose := !n.IsOk()
-			if !needClose {
-				r, ok := n.Ok()
-				needClose = ok && (r == Lf || r == Cr || r == C_C || r == C_D)
-			}
+			r, ok := n.Ok()
+			needClose := !ok || r == Lf || r == Cr || r == C_C || r == C_D
 
 			if needClose {
 				close(next)
@@ -317,22 +314,21 @@ func (in *input) nextChar() (key nkey) {
 		return
 	}
 
-	var s Sequence
 	switch r {
 	case Bs:
-		s = A_Bs
+		key = nk(keyS(A_Bs))
 	case 'O':
-		return in.escO()
+		key = in.escO()
 	case '[':
-		return in.escBracket()
+		key = in.escBracket()
 	case 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
 		'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z':
-		s = Sequence(r << 16)
-	default:
-		return
+		key = nk(keyS(Sequence(r << 16)))
+		//default:
+		//	return
 	}
 
 	in.clear()
 
-	return nk(keyS(s))
+	return
 }