World: r3wp

I guess, it should give you same result as if you print it...

>> print head insert/dup "" "{" 64
{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{

isn't this a little bit strange?

x: [tmp: copy [] loop 5 [insert tail tmp random 100] probe tmp tmp]
reduce compose [(x)]

===  [[53 12 4 15 71] [] [53 12 4 15 71] [53 12 4 15 71]]

hmm... probably not... now i see that it's normal reduced result 
for:    [ (tmp: copy [] ) (loop 5 [insert tail tmp random 100]) (probe 
tmp) (tmp)]

so forget it:-) maybe I should stop working today

does anyone have a function to calculate the age of a person exactly? 
I need maximum precision in that his birthday is correct every time.

including leap years

There is a rebol.org script that prints age to the second.  New user 
wrote it so it

assumes you were born at midnight.   %now.r  Probably needs a pro 
touch up.

well, it simply subtracts dates

Where does it produce incorrect results? Do you have a good test 
case or two. I think stuff I've done is based on the same simple 
concept.

hmm... it looks like REBOL will do it right as long as you don't 
take leap years into account

the question is, how do handle people born on the 29th of feb.

even if you have number of days, its quite hard to then figure out 
the number of years/days correctly... especially when displaying 
them.

days-between: func [date-1 [date!] date-2 [date!]][
    return date-1 - date-2
]

persons-age: func [
    "Return a persons age, in years."
    b-day [date!]
    /precise   "Include decimal portion of age."

    /days      "Return result as how many *days* old the person is."

    /yrs-days  "Return result as number of years and days (2 item block)."

    /on        "Use alternate date instead of current date, to figure 
    age."
        date
    /local result
][
    date: any [date now]
    if days     [return days-between date b-day]
    if precise  [return (days-between date b-day) / 365.25]

    if yrs-days [return compose [(to-integer date - b-day / 365.25)(date 
    - b-day // 365.25)]]

    ; otherwise, take away 1 year if their birthday hasn't come yet this 
    year.
    return date/year - b-day/year - either any [
        (date/month > b-day/month) all [

            (date/month = b-day/month)(date/day >= b-day/day)]] [0][1]
]

the problem is to hit their birthdate correctly, so 38.9 turns to 
39 exactly on their birthdate

round/down :-)

gregg, yes, but still leap year to take into account

wow, it seems to do it correctly. at least for the dates tested here

gregg, is it yours? I need to credit it.

Yes, it's mine. Well, either it's mine or I forgot to keep a credit 
for it, which I'm usually pretty good about. :-)

It has my birthday in the tests, so I'm guessing I wrote it.

seems to be missing by a day here...

oh, well. I'll see what the customer says :-) many thanks!

Send me test cases that fail and I'll try to make it right.

I will. Perhaps you should add it to the code snippet check list?

Feel free.

done

Thanks.

Is there a loader for Targa images (.tga)? Does it require a license 
to support the Targa format? Does anybody know?

I need a REBOL->C converter. I spend hours programming in C to do 
something, it'll take minutes to do in REBOL.

R3 runs as a DLL......Car showed his basic development C script at 
DevCon.

It was abouy 12 lines of C, the heart of it being a call to REBOL, 
passing a string to be DOne.
That may be all you need to run REBOL from C with R3.

It's not actually that, I'm after. In this project I need all the 
speed, I can get, so I do it in C, but it's a lot of time spent. 
I was thinking about a dialect in REBOL, that can be converted to 
C and compiled. That way it should be possible to produce C source 
a lot faster, than I do now.

Something like:
[img: load-image/tga %gfx/image.tga]

The converter should then convert that to a lot of C source, that 
I can compile with gcc.

I wrote a dialect that is converted to C and compilable. It just 
covers basic math operations though, as that was all I needed. No 
pointers stuff and so on. But if you're interested to expand it, 
I can publish it somewhere (not sure how ugly the code is, didn't 
touch that in year or so).

Rebolek, thanks for the offer, but I haven't got the time right now. 
Maybe it'll be a good idea to take this idea up, when R3 is released 
with rebcode. Then it'll be the right time to check the possibilities 
regarding performance.

geomol, if you don't have much time, try D, or Scheme, or any other 
high level compiled language. they're still better than C :) otherwise... 
you'll probably have to code it yourself.

D is a good language.

See http://www.rebol.org/cgi-bin/cgiwrap/rebol/documentation.r?script=view-html.r
for
a little blurb on D.  It is a good language...

Is there a way to change the format of to-date?  In oracle you can 
specify to-date(field, 'MM-DD-YYYY') and I need to read in a lot 
of dates that are in MM/DD/YYYY, but to-date assumes it's DD/MM/YYYY. 
 I also have dates that are Month DD, YYYY.

This will cover mm-dd-yyyy format, but you'll need to add another 
support func for the last format you posted:

parse-simple-date: func [
	"Parse a string containing a date value; return a date! value."
    date [any-string!]

    /def-day def-d [integer! word!] "Default day for mm/yyyy format. 
    Number or 'last."
    /local dig sep d m y set-def-day tmp-dt
][
    dig: charset [#"0" - #"9"]
    sep: charset " -/."
    set [d m y] none
    set-def-day: does [
        d: any [
            all [integer? def-d  def-d]
            all [
                'last = def-d
                foreach fld [d m y] [set fld to integer! get fld]
                tmp-dt: subtract make date! reduce [1 m + 1 y] 1
                tmp-dt/day
            ]
            1
        ]
    ]
    ; assuming mm/dd/yy or mm/yy format
    ; Do we really want to use PARSE/ALL here?
    either parse/all date [

        [copy m 1 2 dig  sep  copy d 1 2 dig  sep  copy y 1 4 dig]
        | [copy m 1 2 dig  sep  copy y 1 4 dig  (set-def-day)]
    ][
        foreach fld [d m y] [set fld to integer! get fld]
        ; add century if necessary; window from 1926-2025
        if y < 100 [y: add y pick [1900 2000] y > 25]
        ; swap day and month if it makes sense
        if all [m > 12  d <= 12] [set [m d] reduce [d m]]
        make date! reduce [d m y]
    ][none]
]


set 'date-val func [
	"Do everything possible to convert a value to a date."
    date

    /def-day d [integer! word!] "Default day for mm/yyyy format. Number 
    or 'last"
    /local res
] [
    if any-string? date [trim date]
    any [
        all [date? date  date]
        parse-simple-date/def-day date any [d 1]
        attempt [to date! date]
    ]
]

Thanks!

D seems to have garbage collection. Then it isn't for this project, 
I'm doing. I can't have the computer having hiccups, because the 
garbage collector does some cleanup.

I'm ok with C for now. I was just pointing out, that REBOL dialects 
producing C source could be very useful for some kinds of programming 
problems. When I got the time ... ;-)

Geomol;  You can use std.gc.disable() for smooth runtime, and std.gc.enable() 
when 
and or if you want to turn the garbage collector back on.

See http://www.digitalmars.com/d/memory.html#realtime

They've thought about it! :-) Neat.

Yeah, my exposure to D is less than a month old, but I'm becoming 
quite a fan of
Walter.