World: r3wp

sort/skip/compare data 3 2

The 2 passed to /comapare means the second field.

Clever -- I didn't know that. Thanks. 

But I tend to use the compare function to get stable sorts.  The 
[x < y]  was just  to shorten the example.

(sorry, /compare)

What, sort isn't stable?

I've always found it to be so.

Not unless you return +1 ,0,  -1
Returning true/false is not guaranteed to be stable

Sort hasn't crashed on me if that's what you mean by unstable.

It's not.

Stable is to do with the order in which duplicate keys are returned.

Looks like stable camwe with /core 2.5
http://www.rebol.com/docs/core25.html

Any mathematicians here ?

On this page : http://www.mja.com.au/public/issues/178_03_030203/sim10248_fm.html#CHDBFAJE

There is this formula


Absolute CVD risk can be calculated from the formula: Probability 
of CVD = 1/(1 + e- k ), where k = – 8.65 + 0.057*age – 0.61*sex + 
0.749*antihypertensive medication + 0.008*systolic blood pressure 
+ 0.458*smoking + 0.18*cholesterol – 0.234*HDL cholesterol + 0.857*diabetes.

what does e stand for ?  Is that some type of log calculation ?

The exp function in REBOL?

It's a long time since I did any high school math :(

cvd: divide 1 1 + exp negate (-8.65 + (0.057 * age) - (0.61 * sex) 
+ (0.749 * ahm) + (0.008 * sbp) + (0.458 * smo) + (0.18 * cho) - 
(0.234 * hdl) + (0.857 * dia))

Based on the formula on the page there.

e is a constant - log is base 10 by default, ln (natural log) is 
base e

(ln = log-e in Rebol)

The exp function calculates e raised to the exponent of the argument 
to the function. If you look on the the web page he is referencing, 
you will see that where he puts e -k, the -k is in superscript, indicating 
that it is to be treated as an exponent.

Great. My function gives the same result as yours.

Seems however, that sex is 1 for female, and 0 for male for this 
to work ( being male confers a higher risk ).

Does now/time give military time?

Almost, no leading zero. Try: now/time + 12:00

If I have an object with a function:
o: make object! [f: func [] [print "Hello World!"]]

Is there a shorter/faster way to get the function without evaluating 
it than:
get in o 'f
?

Shorter?
g i o 'f
:)

lol :P

Is there some way to send the html of a web page to the Rebol 'browse' 
function without actually writing the html file?

the browser has to read a file...

or  stream of data.

here's a quick demo..

rebol []

theTOC: ask "Table of contents (seperate with <p></p> tags): "
theHeader: ask "Header: "
theNumOfBars: ask "Number of chart bars: "
outputPath: ask "Save path (with trailing / ie: c:/): " 


getTemplate: read http://o7o.org/files/aflax/examples/barchart/barchart.html

getSWF: read/binary http://o7o.org/files/aflax/examples/barchart/aflax.swf

replace/all getTemplate "$TOC" theTOC
replace/all getTemplate "$theHeader" theHeader
replace/all getTemplate "$numOfBars" theNumofBars

write to-rebol-file join outputPath "barExample.html" getTemplate
write/binary to-rebol-file join outputPath "aflax.swf" getSWF
browse to-rebol-file join outputpath "barExample.html"

oops wrong group

Yes, you can "browse http://127.0.0.1:123456" and have a small server 
to send the page to the browser.

is it possible to set the args of an error explicitely, instead of 
giving a string?

found it: http://www.rebol.com/docs/core23/rebolcore-17.html#section-5

What will be the closest to lisp CONS method in rebol?

thats for building lists? insert/append ?

Is for building list using mutually recursive funcs.

and at the end you have something linear, so you could use block! 
or list! ?

I tried using reduce but it didn't quite work. Append failed completely. 
Maybe I need a way to keep a block.

do you have a lisp-example?

Yes.

(define subst
  (lambda (new old slist)
    (if (null? slist)
        '()
        (cons 
         (subst-in-symbol-expression new old (car slist))
         (subst new old (cdr slist))))))

(define subst-in-symbol-expression
  (lambda (new old se)
    (if (symbol? se)
        (if (eqv? se old)
            new
            se)
        (subst new old se))))

(subst 'a 'b '((b c) (b () d)))

== ((a c) (a () d))

Here is my approach in rebol.

sub-sb: func [new old slist][
    either empty? slist [
        []
    ] [
        reduce [
            sub-sb-in-symbol new old slist/1 
            sub-sb new old next slist 
        ]
    ]
]

sub-sb-in-symbol: func [new old se][
    either word? se [
        either :se = :old [:new] [:se]
    ] [
        sub-sb new old se
    ]
]

>> sub-sb 'a 'b [[b c] [b [] d]]
== [[a [c 
            []
        ]] [[a [
                [] [d 
                    []
                ]
            ]] 
        []
    ]]

So not linear, but a tree. And you use blocks as lisp-pairs.