Please let me know if you see any coding errors, and of course any

feedback is welcome.

That is you can do the usual

Int arithmetic in the ranges Inf..^Inf*2 and -Inf*2^..-Inf except

that Inf has no predecessor and -Inf no successor. Well, and we lose

commutativity of + and *. I.e. 1 + $a != $a + 1 if $a is transfinite.

Firstly, shouldn't there also be infinite strings? E.g. 'ab' x Inf

is a regularly infinite string and ~pi as well. Other classes might

have elaborate notions of infinity.

The Complex e.g. might have an

angle associated to an Inf.

Secondly, you only have a single Inf constant and its negation. But

there should be a multitude of infinities. E.g. a code fragment

my Int $a = random(0..1) > 0.5 ?? 3 !! Inf;

my Int $b = $a + 1;

say "yes" if $b > $a;

should always print "yes". That is we continue counting after Inf such

that we have transfinite ordinals.

0, 1, 2, ..., Inf, Inf+1, Inf+2, ..., Inf*2, Inf*2+1, ...

The implementation is strait forward as an array of coefficients

of the Inf powers with Inf**0 == 1 being the finite Ints. The sign

bit goes separate from the magnitude. That is you can do the usual

Int arithmetic in the ranges Inf..^Inf*2 and -Inf*2^..-Inf except

that Inf has no predecessor and -Inf no successor. Well, and we lose

commutativity of + and *. I.e. 1 + $a != $a + 1 if $a is transfinite.

I'm not sure if such a concept of "interesting values of infinity"

is overly useful, though. In TeX e.g. there are infinitely stretchable

spacings of different infinitudes so that they overwrite each other.

Also I think we can have finite conceptual infinities for types like

int32 and num64. In the latter case we also have infinitely small

values and "infinities" like sqrt(2). In short everything that falls

out of the finite range of these types and is captured in Int or Num.

BTW, with an infinite precision Num I see no need for the Rat type!

Yes. But the Hyperreals do the same and stay within the realm

of set theory.

my @evenodd = 0..Inf:by(2), 1..Inf:by(2);

can be indexed as follows

say @evenodd[3]; # 6

say @evenodd[Inf+1]; # 3

say @evenodd[^3]; # 0 2 4

say @evenodd[Inf «+« ^3]; # 1 3 5

Even in the finite case one has to know the index where the transition

from even to odd is made. In the infinite case this point has the nice

name Inf that's all. Good question is if one can expect

say substr('ab' x Inf ~ 'ba' x Inf, Inf-1, Inf+1);

to print 'bb' on the rational that the structure is 'ab...abba...ba'

With the core of the

language mandating the Inf type every programmer must be aware of

potentially infinite loops etc.

I'm not sure. A quick reading indicates that contains "infinitely large"

numbers that maintain the properties of addition, but that is not the same

as "infinity".

The proposed Infinite class (see the thread I started on 4/25/2008) does

handle transfinite cardinals.

The Num type is not infinite precision, but the highest-precision native

type that operates at full speed. Since there are high or arbitrary

precision float libraries available now, I'm sure CPAN6 will include some.

Supporting multiple levels of infinities, transfinite numbers or even Surreal Numbers should be considered in the same category of features as returning multiple answers from complex trig functions.

They're an interesting thing to discuss and experiment with but shouldn't distract form getting Perl 6 out the door. Let's just make sure we're handling inf and -inf right and leave all that other stuff until later.

--

Mark Biggar

mark@biggar.org

mark.a.biggar@comca­st.net

mbiggar@paypal.com

IMO to include something related to infinity you need to stick with

some particular model and forget the rest.

Let's just make sure we're handling inf and -inf right and leave all

that other stuff until later.

IMO to include something related to infinity you need to stick with

some particular model and forget the rest.

Could we get confirmation for that from @Larry. I remember $Larry

mentioning that Num fails over to Rat or so when necessary. IOW,

does

my Rat $rat = 1/3; # assuming infix:</> returns a Rat

my Num $num = 1/3;

my Rat $diff = abs($rat - $num);

store a non-zero value in $diff? I assume that Num is discrete with a

binary representation and infix:<->:(Rat,Num-­->Rat) converts $num to a

fraction with a power of two in the denominator. BTW, with floor

semantics I would expect $num < $rat.

HaloO,

mark.a.biggar@comca­st.net wrote:

The point is: what is the minimum we need to be future proof

and compatible to other language features.

Regards, TSa.

On Thu, Aug 7, 2008 at 11:29 AM, <mark.a.biggar@comc­ast.net> wrote:

+1