World: r3wp

btw - what you think of following? - normally we can access paths 
in several ways ... block/5 (fifth element), block/literal (literal 
element), block/(expression) (expressionn to evaluate). Nonexistant 
elements do return 'none. But try block/("some string") - it returns 
error. Now the question is, if this is correct/consistent with other 
ways of how we access block elements, or not?

Question: <Unix Time>..   I found several functions on the web that 
show you how to create a unix-timestamp from a rebol time (now). 
 However, I am looking for the ability to convert a unix-timestamp 
back into rebol-time.  I started writing my own function but I think 
that leap-years might mess me up.  Anyone have any thought on the 
matter?

!> now + to-time 1e6
== 23-Oct-2005/13:26:16+2:00

i guess you can refine that for conversion. a unix-timestamp is an 
integer based on some date?

1/1/1970 0:00:00

an then 32 bits for miliseconds or something like this?

The unix-timestamp could be any date/time.. so I think I have to 
work top down.. first find the year then month, day, hour, min, sec. 
    Kind of like building a binary number from a decimal.. top-down.

Precision (ms) is used/not used depending on the OS / config.

I have some MRTG/RRDTool files that I am parsing for certain data 
and they all use the unix-timestamp format (not including ms)

i thought it is just an integer. So it is more complicated build, 
with year, month etc?

Yeah.  the date -> unixTime function from someone else (maybe Gabrielle) 
is..
to-unix-time: func [date] [
  date/date - 1-1-1970 * 86400 + to-integer date/time
]

then you could reverse that. as my example shows, you can add times 
to dates. i think it works also in that large range.

Yeah.  My problem (I think) is accounting for leap years and the 
different lengths of months.

Little casio watches know all of this info (Year/month/day/time). 
 I suspect it is in a static table inside the watch.  I have been 
looking for something like this on the web.

I could easily build a table for month lengths.. it is the leap-year 
that I just don't want to think about.

That should be inbuild. i guess rebol stores internally just a big 
integer too.

you could try
  1-1-1970 + unix-seconds
and see what happens.

1-1-1970 + to-time unix-seconds

You might be on to something.. I did unix time (now) and it returned 
24-Dec-13007.  However, maybe I need to subtract not add.  I will 
play with this SIMPLE solution.  (I always try to look at it harder 
than it probably needs to be).  Thanks.

>> 1-Jan-1970/0:0:0 + to-time to-unix-time 15-Apr-2006/15:41:0
== 15-Apr-2006/15:41

Looks like the time just needs to be inlcuded...

i've this function: f: [variable] [variable: 100]
variable: 10
f variable
== 100
variable
== 10

the question is 1 why do i never noticed this :) and second how do 
i pass values by reference

You're not talking about this ?

 f: func ['word][ set word 10 ]

This might do it -- change the way you define f:
 use [variable] [f: [variable] [variable: 100]]
variable: 10
== 10
f variable
== 10
variable
== 10

note: "variable" is a global value still i get no results from this 
:(

>> f: func ['variable][ set variable 100 ]
>> variable: 10
== 10
>> f variable
== 100
>> variable
== 100

thanks graham it worked well

I rarely change values by reference, only series/objects. values 
i simply assign new.
 f: func[variable][100]
 variable: variable 100
If not, i at least mark the word, like
 f: func[variable][ set variable 100]
 f 'variable

Its style, but in rebol i rarely see a function changes a word, so 
i am avoiding to be surprised.

O.K.
Thanks to everyone for their help.

I offer my final (not that it's the best) rendition of these conversion 
functions.


to-unix-time: func [
  "Create unix-timestamp.  Author: Gabriele_3-Aug-2002."
  date [date!] "Rebol-format date. (non-Milisecond type)."
][
  date/date - 1-1-1970 * 86400 + to-integer date/time
]

from-unix-time: func [

  "Create rebol-timestamp from unix-timestamp.  Author: Rebolers-Altme_2005."
  utime [integer!] "Unix timestamp."
][
  unixTimestampConstant + to-time utime
]  

-- OR an all-in-one --

unixTimestamp: func [

  "Rebol date to/from unix timestamp conversion.  Authors: Many rebolers.."

  varIn "Enter either a Date!type or Integer!type to convert to/from 
  unix/rebol."
][

   unixTimestampConstant: 1970-01-01/00:00:00           ;Reference.
   varOut: "ERR"

   if ((type? varIn) = date!) [                         ;from rebol, 
   to unix.

     varOut: varIn/date - 1-1-1970 * 86400 + to-integer varIn/time
   ]

   if ((type? varIn) = integer!) [                      ;from unix to 
   rebol.

     if (varIn >= 0) [                                  ;B.U.  (before 
     Unix.)
       varOut: unixTimestampConstant + to-time utime
     ]
   ]
   return varOut
]

John.

>> difference now 1-1-1970
== 313646:34:14
>> to integer! difference now 1-1-1970
== 1129127658

BIG TYPO on the last post.. 

unixTimestamp: func [

  "Rebol date to/from unix timestamp conversion.  Authors: Many rebolers.."

  varIn "Enter either a Date!type or Integer!type to convert to/from 
  unix/rebol."
][

   unixTimestampConstant: 1970-01-01/00:00:00           ;Reference.
   varOut: "ERR"

   if ((type? varIn) = date!) [                         ;from rebol, 
   to unix.

     varOut: varIn/date - 1-1-1970 * 86400 + to-integer varIn/time
   ]

   if ((type? varIn) = integer!) [                      ;from unix to 
   rebol.

     if (varIn >= 0) [                                  ;B.U.  (before 
     Unix.)
       varOut: unixTimestampConstant + to-time varIn
     ]
   ]
   return varOut
]

John.
BIG TYPO on the last post.. 

unixTimestamp: func [

  "Rebol date to/from unix timestamp conversion.  Authors: Many rebolers.."

  varIn "Enter either a Date!type or Integer!type to convert to/from 
  unix/rebol."
][

   unixTimestampConstant: 1970-01-01/00:00:00           ;Reference.
   varOut: "ERR"

   if ((type? varIn) = date!) [                         ;from rebol, 
   to unix.

     varOut: varIn/date - 1-1-1970 * 86400 + to-integer varIn/time
   ]

   if ((type? varIn) = integer!) [                      ;from unix to 
   rebol.

     if (varIn >= 0) [                                  ;B.U.  (before 
     Unix.)
       varOut: unixTimestampConstant + to-time varIn
     ]
   ]
   return varOut
]

John.

Is there a way to have small decimal numbers shown, as you write 
them, when converted to a string? Instead of this:
>> to-string 0.08
== "8E-2"
I would like the output to be "0.08".

:-)) last week or so there was rather long discussion here :-)

I have form-decimal function for that, but others might have posted 
other solutions ...

wait a bit - will look into my flash disk if I have it here, otherwise 
I have it at my work on my PC ...

ok

try this - found some arcane version, hopefully it will work ...

form-decimal: function [num][tmp main rest sign base][

     either found? find tmp: to-string num "E" [

              parse tmp [
                 copy main to "."
                 skip
                 copy rest to "E"
                 skip
                 mark: (sign: copy/part mark 1)
                 skip
                 copy base to end
               ]


        either sign = "-" [

                tmp: "0."

                loop ((to-integer base) - 1) [insert tail tmp "0"]
                insert tail tmp rest
        ][
                tmp: copy ""

                insert tail tmp join main rest

                loop ((to-integer base) - (length? rest)) [insert tail tmp "0"]  
                    
                           
        ] 
     
      tmp                 

     ][num] 

]

but please - take into account that my coding capabilities are, ehm, 
rather weak :-)

:-) Ok, thanks Pekr!

eh, does not seem to work ...

I will look into it and try to post correct version ...

Try this one:

form-decimal: func [num /local tmp main rest sign base][

     either found? find tmp: to-string num "E" [

              parse tmp [
                 [copy main to "." 
                  skip
                  copy rest to "E"
                  |
                  copy rest to "E"
                  (main: copy "")  
                  ]
             
                 skip
                 mark: (sign: copy/part mark 1)
                 skip
                 copy base to end
               ]


        either sign = "-" [

                tmp: copy "0."

                loop ((to-integer base) - 1) [insert tail tmp "0"]
                insert tail tmp rest
        ][
                tmp: copy ""

                insert tail tmp join main rest

                loop ((to-integer base) - (length? rest)) [insert tail tmp "0"]  
                    
                           
        ] 
     
      tmp                 

     ][num] 

]

first one did not take into account 1E-2, simply a version, where 
there is no "." in it ....

and I believe folks here will introduce just few lines version later 
:-)

On 6-October Volker posted this reply:


Pekr: "I did not find an easier way, so I parse for E, then I distinguish 
the sign, the number -5 in above case, and then I compose the string 
:-)"
!> a: 123.456 reduce[to integer! a remainder a 1]
== [123 0.456000000000003]

Maybe the base for something better (dont know how easy that parsing 
is?)

turned out to be http://polly.rebol.it/test/test/snippets/epad1.r
. longer and not so readable. but seems to work.

I think, this version do the job:

form-decimal: func [n /local p d] [
	if p: find n #"E" [
		if d: remove find n #"." [d: index? d p: back p]
		if not d [if d: remove find n #"," [d: index? d p: back p]]
		if not d [d: 2]
		either p/2 = #"-" [
			insert/dup n #"0" (to-integer skip p 2) - 1
			insert n "0."
		][
			insert/dup p #"0" (to-integer next p) - (index? p) + d
		]
		clear find n #"E"
	]
	n
]

nope, not quite

This must be it: