> (+ 5/3 4/5)
37/15
> (expt #C(0 1) 2)
-1
> (expt #C(3/2 1/2) 2)
#C(2 3/2)
And of course they all support arbitrary precision numbers as well: > (complex (fact 10) (fact 20))
#C(3628800 2432902008176640000)
> (/ (complex (fact 10) (fact 20)) 29)
#C(3628800/29 2432902008176640000/29)
Composition is a wonderful thing. > WHAT 1/10
(Rat)
> WHAT 1/100000000000000000000
(Num)
(There is FatRat, which does not so 'promote', but it is not the default.)in raku, for example, an Int is not an isa (grand)child of Complex (and so doesn't carry that overload) ... but yes it is a Real
so raku separates Real from Complex and Int from Rat and you can go eg. my $x = 1 ~~ Rat; #False and this is aligned with literals - 1 vs 1.1
and then you play nice if things overflow
See: https://docs.raku.org/language/variables#$*RAT-OVERFLOW*
We could (and have) debate whether FatRat should be the default, but imo the right expectation for an untyped language should be that very large or small numbers are represented with a floating point representation that (i) uses the FPU that's right there and (ii) sacrifices precision in the mantissa for accuracy.
Since Raku has (gradual) types, you can easily specify what you want and throw an error.
`INIT $RAT-OVERFLOW = Exception` will throw an exception whenever a switch to Num would happen.
If you want to define your own behaviour, you can. For instance:
class ZeroOrInf { method UPGRADE-RAT(Int $nu, Int $de) { $nu > $de ?? Inf !! 0 } } INIT $*RAT-OVERFLOW = ZeroOrInf
would either convert the value to `Inf`if too large, or to `0` if too small.
Please bear in mind that in raku (like perl and other untyped scripting languages) it is normal to say:
my $x = 1; say 1 + $x; #2 say 'a' ~ $x; #'a1'
My point is that when the type is automatically inferred/coerced like this, is is very natural that small/whole Numerics are Int, that medium/fractional/decimal Numerics are Rat and that large/exponential Numerics are Num (ie double). And that you can freely perform maths operations mixing the various Numeric types at will.
my $y = 1; say 1 + $y; #2 Int say 1.1 + $y; #2.1 Rat say 1e27 + $y; #1e27 Num
And, in raku, if you want to control the type, then just use the type system like this.
my FatRat $r;
I also think from a 2nd order point of view that a denominator of 2*64 means you are dealing with quite a small number 5e-20 ish), although admittedly that is a matter of taste and machine performance. It makes most sense in my view to go with Rat (which is stored as an Int (uint64) for the numerator and an Int for the numerator.
That way (i) you get to use all those transistors that you bought for your FPU and (ii) you do not get a surprise as Rat operations perform slowly without warning.
--- And yes - @lizmat has pointed out the various pragmas to let you control the behaviour you want if you disagree.
Scheme’s numeric tower has a handled exact expressions with exact representations correctly for decades, so I guess its true that is not “moving away from” unnecessary and error-prone use of inexact floats where not explicitly requested, but only because it was never there to move away from.
> (/ 1.0 3.0)
0.3333333333333333
> (/ 1 3)
1/3
> (- (+ 0.1 0.2) 0.3)
5.551115123125783e-17For what it's worth I agree with you when it comes to languages where 50+x overhead isn't an ever-present fact; you should generally have to opt in to using decimal types and the like.
Also, related and recent:
Ask HN: Are you using Raku? Pros / cons?
https://news.ycombinator.com/item?id=36922692
Question inspired by starting to watch this: Raku for Beginners, at TPRC 2023:
> The following built-in types inherit from Cool: Array Bool Complex Cool Duration Map FatRat...