add a modulo operator

[sylvainpolletvillard]

Hi there,

We can already do pretty cool stuff using rockstar, but some basic features are lacking. At the top of my list: a modulo operator.

I know that you can already declare one using this function:

Modulus takes Number and Divisor
While Number is as high as Divisor
Put Number minus Divisor into Number
    (blank line ending While block)
Give back Number

But unsurprisingly, it is painfully slow, especially when dealing with huge numbers.

Proposal: {a} remains {b} - modulo . Open to any other aliases

As encouragement, know that this is the last thing that prevent me to finish my Game of Life implementation in Rockstar 👾

[dylanbeattie]

Hey - Game of Life sounds really interesting. Which compiler/interpreter are you using to develop it?

I like the idea of remains purely because it would mean The song remains the same would be a valid expression... it might get in based on that alone :)

Right now, though, I'm working to get a stable 1.0 release candidate along with a proper regression test suite, which should be done in the next few days - once we've got that, I'm gonna triage any other feature suggestions for 1.0 and see if it's easy enough to add them without breaking anything.

[sylvainpolletvillard]

I use https://github.com/yanorestes/rockstar-py ; it gave me the best results so far, even if every interpreter has its own issues.

Here's the Game of life implementation for anyone interested: https://github.com/sylvainpolletvillard/gameofrockstars

[ascheja]

Depending on the size of your numbers you could try something like this:

Modulus takes Number and Divisor
Put Divisor times 1000 into Big Divisor
While Number is as high as Big Divisor
Put Number minus Big Divisor into Number
    (blank line ending While block)
While Number is as high as Divisor
Put Number minus Divisor into Number
    (blank line ending While block)
Give back Number

[sylvainpolletvillard]

My numbers go from 0 to 2^64, so I would need a couple of these intermediate divisors, and it would still be very slow.

[dylanbeattie]

That is absolutely amazing. Just... wow

\m/

[gaborsch]

I'm not against the Modulo operator, but let me show you another, quicker solution for the Modulus function:

Modulus takes Number and Divisor
Put Divisor into Big Divisor
While Big Divisor is less than Number
Put Big Divisor times 2 into Big Divisor
    (blank line ending While block)
While Big Divisor is as high as Divisor
If Number is as high as Big Divisor
Put Number minus Big Divisor into Number
    (blank line ending If block)
Put Big Divisor over 2 into Big Divisor
    (blank line ending While block)
Give back Number

For a big number of 2^64 mod 1, it will end in 2*64 cycles. For smaller Numbers and bigger Divisors it is way faster.

[gaborsch]

BTW, a Floor function would be useful, too. With the Floor, we can express the Modulo function, too.:

a mod b = a - b * Floor(a/b))

[sylvainpolletvillard]

Yes, or vice versa, Floor(n) = n - n%1

Your method is indeed way faster, good enough for my usage. But it only works for integers, so it cannot be applied for the Floor function shown above.

[gaborsch]

@sylvainpolletvillard Glad to help you!