World: r3wp

decimal! and integer!

where the latter specifies the number of decimal places

The task is to convert from scientific notation to numbers only

I just have the feeling that it should be done with only few lines

*could be

Graham, this is a replacement for Gabriele's version. This one is 
more complete.

The primary issue is overcoming REBOL's varying usage of scientific 
notation. That's one reason it's so big (but still smaller than Gabriele's).

I've done my own, and its similar, in size and functionality... not 
much to do... the scientific notation is a pain to manage.

I suggest we fix core so that it triggers scientific notation at 
7 decimal places as it does in R3 instead of at 2 decimal places 
as it does no.

w.

well, using a "mask" approach, allows more capabilities then just 
providing the number of decimals.

Like I've done here for R3: http://www.rebol.net/cgi-bin/r3blog.r?view=0302#comments
(see fnum)


It's true, it doesn't handle scientific notation as entry currently, 
but hey !, it should not take more than 2 or 3 more lines.

I'd rather we didn't have the problem in the first place!

Yes, agree. I'm helping building a rather large app, where this is 
important and when things like this aren't trivial to solve... But 
what ever happens, I think we need a function like this in R3 and 
R2-Forward.

It should be part of a general FORMAT func IMO.

The disadvantage to that is that it makes the FORMAT function more 
complex, and thus slow.

It's just chocies. Format, as it stands, isn't something I'll use. 
And if someone shows me a case where the overhead has a noticable 
and visible impact on their code, I will refactor a custom version 
for them. :-) 


I'm open to discussion, scenarios, and the backs of envelopes. Where 
is FORMAT likely to be used, how often will it be called, and how 
slow is too slow?

Numeric formatting should be fast enough to get called in a tight 
loop for grid output. Thousands of times, really quickly.

well, if you format you change the type

in rebgui at least

Sounds like RebGUI needs grid formatting.

Brian, great example. It also highlights that we may want it to accept 
sets of values as well as single values.

Single value formatting is exactly the kind of thing that could use 
the /into option, for buffer reuse.

I have a large, non-optimzed FORMAT function, but couldn't remember 
profiling it. I just did a few quick tests.

>> time-it/count [format d "yyyy-mmm-dd"] 1000
== 0:00:00.094
>> time-it/count [format d 'rel-time] 1000
== 0:00:00.078
>> time-it/count [format 1000.01 'general] 1000
== 0:00:00.047
>> time-it/count [format 1000.01 'reb-general] 1000
== 0:00:00.031
>> time-it/count [format "Gregg" [10 right]] 1000
== 0:00:00.031
>> time-it/count [format "Gregg" [10 right #"."]] 1000
== 0:00:00.016
>> time-it/count [format true 'on-off] 1000
== 0:00

Are those results too slow?

I have no idea. It's easier to judge by DP than DT (the equivalent 
of time-it).

How so? I haven't used DP.

It will tell you evaluations and series created, which is a bit more 
cross-platform reliable than time. Don't know how fast your CPU is.

to compare our CPUs we can use SPEED?
==2100 on my Celeron

(with R3)

SPEED? sould be ehnanced to output system informations (like the 
CPU, frequency and OS)

seems there is a bug in it:

form-decimal -100 1
== "-.100,0"

Anyone with a fix?

Some time ago, I did form-decimal function too. But I am really a 
coding lamer, so dunno, if it cover at least half the cases other 
versions do. Here it is:

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] 

]

Graham, wouldn't it be more appropriate to simply never output scientific 
numbering and then create a scientific formatting function?

Here's Gabriele's original version

form-decimal: func [   num     [number!]
        cifre   [integer!]

        /local sign str poscifre int frac pow
    ][   sign: either negative? num [#"-"] [""]
        str: make string! 16
        either zero? num
        [   insert str #"0"
            if cifre > 0
            [   insert/dup
                    insert
                        tail str
                        #","
                    #"0"
                    cifre
        ]   ]
        [   num: abs num
            num: form
                add
                    multiply
                        power 10 cifre
                        to-decimal num
                    0,5

                        ; mainly WINE bug workaround - might also work for larger numbers 
                        on Windows
                        if find num "E"

                        [       parse num [copy int to "." skip copy frac 15 to "E" skip 
                        copy pow to end]
                                pow: to integer! pow
                                either pow >= 0
                                [       insert/dup
                                                insert/part

                                                        insert clear num int
                                                        frac

                                                        skip frac pow
                                                #"0"

                                                pow - length? frac
                                ]
                                [       num: "0"]
                        ]
            clear any [find num "." ""]
            poscifre: skip  tail num  negate cifre
            insert/part insert str sign num
                num: skip num
                    1 + remainder
                        subtract
                            index? poscifre
                            2
                        3
            while [(index? poscifre) > (index? num)]
            [   insert/part
                    insert
                        tail str
                        #"'"
                    num
                    num: skip num 3
            ]
            if empty? str [insert str #"0"]
            if not tail? poscifre
            [   insert
                    insert/dup
                        insert
                            tail str
                            #","
                        #"0"
                        cifre - length? poscifre
                    poscifre
            ]
        ]
        str
    ]

quite long :-)

is form-decimal for scientific format for really large/small numbers 
like 1.25e+100 ? or is it for stuff like money 12.300,00 ? I have 
a function for the money :) (formating) , it's quite short if I remember 
correct.

That's a good point, if you only need a couple of decimal places, 
the form decimal could be much shorter

SPEED? == 2'450 here.


I very much like the idea of combining heuristics with profiling. 
But if we're just going for rough estimates, we only need to know 
if a machine is extraordinarily fast or slow. Then we say "is 20K 
calls/sec acceptable in terms or order of magnitude?"

form-decimal 4.17E-3
== "0.0017"
form-decimal 4.17E+3
== 4170.0

positive version seems to work.

using Henriks function

first convertion does not work...

negative version is correct too, no? Mine form-decimal returns the 
same ...

sorry, Pekr's version...

should it not be 0.00417?

ah, yes, it is buggy. "4" somehow disappeared :-)

amacleod - the fix is easy - just replace "insert tail tmp rest" 
by "insert tail tmp join main rest"

Thanks Pekr...I did not have time to look at it but I''m working 
on an app that need this function. Thanks.

What's the easiest way to convert from money! back to decimal or 
integer?

In r2:
>> second $12.33
== 12.33

Ok, I see...its a combo of string and decimal..

I think I asked this before or figured it out but now the mind has 
lost the answer. I build strings (via a join) that reference existing 
objects.  Obviously the joining part is easy but of course I end 
up with a string.