World: r3wp

rather optimized...


cidr-match?: funct [address [tuple!] network [tuple!] bits [integer!]] 
[
    mask: to-tuple to-binary shift -1 64 - bits
    mask and address xor network = .0.
]

Heh, that's great Steeve. Esp the ".0."

yeah,
.0. = 0.0.0 = 0.0.0.0.0 ...

Yeah :)

Yeah, silly me, forgot about SHIFT :)

That should work on R2 with 32 instead of 64.

Yup

Nope. You'd need shift/left on R2

He knew... :)

Just a reminder :)

The last time I did IP calculations in REBOL was before 2.7.6 came 
out, so the reminder is appreciated :)

Though your functions do indicate the value of using REBOL's datatypes 
properly. Take note, Pekr, no strings :)

wow, what a bunch of reactions :-) BrianH - I used strings, because 
of original Mikrotik format. They use 10.10.10.10/24 format for IP, 
so it was easier for me to carry around in a string form, then parse 
it later when needed ....


IP arithmetics, and ranges would be 2 nice new datatypes for REBOL 
imo :-)

Steeve - your optimised version for R2 does not work correctly:

>> cidr-match? 10.10.10.10 10.10.10.0 24
== false

Because it was for R3 only, try this for R2:


cidr-match?: func [address [tuple!] network [tuple!] bits [integer!]] 
[

    address xor network and (to-tuple debase/base to-hex shift/left -1 
    32 - bits 16) = .0.
]

Don't know if it's faster than Andreas's, though

(-:-:- = -:0:-) = (0:-:0 = 0:0:0)

-:-

and so:
+:+

I'm trying to figure out which index comes earlier in two different 
references to the same block and was trying with MIN and MAX, because 
I didn't want to resort to LESSER? INDEX? things.


The result with MIN/MAX doesn't seem to be particularly useful. What 
is the basis of comparison of two blocks when using MIN and MAX?

Their contents, not their indexes.

yes, I figure that, but what's the basis for comparison?

...

Their first elements, as in
>> max [0 9 9] [2]
== [2]

are you sure?

>> min [b 1] [b b 2]
== [b b 2]

also because MIN and MAX don't compare on words, so there must be 
a different base of comparison.

>> min reduce [word! integer!] reduce [word! word! integer!]
== [word! word! integer!]

MIN and MAX compare the spelling of words in blocks in R3.

And it's not just the first element:
>> min [b b] [b a]
== [b a]

Henrik just showed that.

If the types aren't the same the datatypes are compared, by the arbitrary 
ordering they have in the type list (the datatype number).

Henrik: it's the same as SORT

would it be possible to have more operators? In !Mikrotik group, 
I am trying do some stuff for MT routerOS API. Thanks to Anton, I 
can now proceed. When "studying" Python code, I found segment like:

elif l < 0x4000:
     l |= 0x8000


1) they can directly compare 'l of integer type to binary value. 
But I might make wrong conclusion here. But 'l is really result of 
len('string here') operation. But - even if so, I don't miss such 
an automation, as I can always write if l = to-integer #{8000}


2) Second line is more interesting - I did not find precisely |=, 
but found e.g. /= ... and it translates like do some operation, and 
assign. In this regard, the only comparable operator of REBOL is 
++ or --, but in R2 this is just mezzanine, in R3 native. But if 
I am right, their code:

l |=0x8000

R3:
l: (to-binary l) or #{8000}


So, if I would assume 'l being of correct type already (binary here), 
would it be possible to have?:

l |= #{8000}


Hmm, that is not probably compatible with REBOL parser and REBOL's 
assigment operator, which is :

If I am completly wrong, then please ignore me, I am not that much 
into the language design stuff :-) But why don't we at least have 
& for 'and, and | for 'or shortcuts?

What's the gain ?

Anyway, you can create your own alias.
In R3 >
|: :or
&: :and

In R2 >
alias 'and "&"
alias 'or "|"

you could use the same (R3 way) aliasing aproach in R2 too, no?

& and | are easy to add. The gain is to have apply & modify operation. 
Maybe there is no gain ... Simply instead of a = a + 10, you can 
write in python a += 10 in Python.

User-defined operators are planned for R3, but for now you have to 
use one of the existing operators, possibly renamed. If you can switch 
to prefix ordering you are less limited.

If R2 the built-in operators are special-cased in the DO function, 
so you can't do the renaming trick.

Is there any bits converter in REBOL? Or not even in rebol? I mean 
- how do I get from 255 or FF to "11111111"? :-)

In R3:
>> to-binary 255
== #{00000000000000FF}
>> enbase/base to-binary 255 2

== {0000000000000000000000000000000000000000000000000000000011111111}
>> enbase/base take/part/last to-binary 255 1 2
== "11111111"


The to-binary part gets more difficult in R2 because of the aforementioned 
bugs in the semantic model.

R2:
>> enbase/base #{FF} 2
== "11111111"

Steeve, the enbase isn't the problem in R2, it's the to-binary.

debase/base to-hex 255 16

To do proper integer to binary conversions in R2 you can convert 
the individual octets of the integer to char and then convert them 
to binary. I'm sure Steeve has more solutions for that though.

As he proved while I was waiting for the post to arrive :)

thanks .... will try to mess with it. The bug in R3 preventing to 
join binarries is really bad ...

I just mentioned it in the a98 call for fixes blog.

ok, thanks. Hopefully Carl notices it ....

I really hope we go through the CureCode tickets soon and collect 
all of the ones that make minor changes to core semantics, so we 
can do a rip-the-bandaid-off fix-them-all release soon. Before too 
much code is written that might depend on the unfixed behavior.