Extending Math Functions

Discussion in 'Javascript' started by cwdjrxyz@yahoo.com, Jun 22, 2005.

  1. Guest

    Javascript has a very small math function list. However there is no
    reason that this list can not be extended greatly. Speed is not an
    issue, unless you nest complicated calculations several levels deep. In
    that case you need much more ram than a PC has to store functions
    calculated in loops so that you do not have to recalculate every time
    you cycle through the nest of loops. Using a HD for storage to extend
    ram is much too slow for many applications.

    Some functions such as hyperbolic ones are easy to add, since they are
    just simple combinations of the built in javascript math functions. I
    have found a few examples on the web such as Bessel functions. I found
    far fewer javascript math functions than I expected on Google searches.
    Thus I have had to write several functions of my own.

    See http://www.cwdjr.net/math/I0L0andI1L1.html for an example of two
    "functions from hell" that are very difficult to evaluate. Fortunately
    there are Fortran programs that can be used as a starting point. I was
    able to modify the Fortran programs to work on javascript. I have used
    these functions for technical applications in the past.

    The page is set up to reject the NN 4 series, because it will not
    support some of the script needed such as .toExponential(n) and
    to.Fixed(n)for writing output in exponential or fixed format. I was
    amazed that even the old MSNTV(former WebTV) set-top box, that no
    longer is being made, will even support these output formats. I wonder
    about IE4. If it will not support these output formats, I can easly
    block it by checking for document.getElementById.

    The code works properly on the latest versions of IE6, MSN9, Firefox,
    Mozilla, Netscape, and Opera. I am not selling anything, so for a
    special interest page such as this, I see no need to support older
    browsers.

    The advantage of doing math with javascript is that it is so portable.
    You can do it anywhere you can use a computer, or you can do it on your
    own local computer offline. There are several math programs for PCs
    that will do very much more than you can hope to do with javascript.
    Unfortunately the program I would like costs about US$ 1800. Also there
    are versions you can install on a server, but these also are expensive.
     
    , Jun 22, 2005
    #1
    1. Advertising

  2. On 22/06/2005 06:02, wrote:

    > Javascript has a very small math function list. However there is no
    > reason that this list can not be extended greatly.


    Have you considered the fact that a large selection of such functions
    would go largely unused, and therefore be a waste of time and resources
    to implement and expose?

    In specialised applications, a host is free to extend what objects and
    methods are implemented, but as far as browsers are concerned, there is
    no benefit in adding lots of methods to the Math object.

    [snip]

    > The page is set up to reject the NN 4 series, because it will not
    > support some of the script needed such as .toExponential(n) and
    > to.Fixed(n)for writing output in exponential or fixed format.


    Implementations of both methods are bug-ridden in some hosts.

    > I wonder about IE4. If it will not support these output formats, I can easly
    > block it by checking for document.getElementById.


    You would be better off blocking browsers based on what they do, or do
    not, support, not on unrelated features. See
    <URL:http://www.jibbering.com/faq/#FAQ4_26> and its links.

    [snip]

    Mike

    --
    Michael Winter
    Replace ".invalid" with ".uk" to reply by e-mail.
     
    Michael Winter, Jun 22, 2005
    #2
    1. Advertising

  3. Guest

    Michael Winter replied:

    > Javascript has a very small math function list. However there is no
    > reason that this list can not be extended greatly.



    Have you considered the fact that a large selection of such functions
    would go largely unused, and therefore be a waste of time and resources

    to implement and expose?

    In specialised applications, a host is free to extend what objects and
    methods are implemented, but as far as browsers are concerned, there is

    no benefit in adding lots of methods to the Math object.


    [snip]



    > The page is set up to reject the NN 4 series, because it will not
    > support some of the script needed such as .toExponential(n) and
    > to.Fixed(n)for writing output in exponential or fixed format.



    Implementations of both methods are bug-ridden in some hosts.


    > I wonder about IE4. If it will not support these output formats, I can easly
    > block it by checking for document.getElementById.



    You would be better off blocking browsers based on what they do, or do
    not, support, not on unrelated features. See
    <URL:http://www.jibbering.com/faq/#­FAQ4_26> and its links.

    There is every benefit to adding at least 20 more standard browser Math
    objects. The standard hyperbolic and other functions that are used by
    even high school students are very easy to add. This should cost very
    little to do. Not everyone is interested in commercial business web
    pages. The ability of javascript to do meaningful calculations on
    browsers has been very much neglected. I have demonstrated that even a
    rather complex function could be added without undue effort. The
    methods for evaluation of most standard math functions were developed
    long before there were even computers to do the math in a short time.
    It is just a part of standard university math.

    If what you mean is that implementation of .toExponential and .toFixed
    has bugs in some hosts is that there are problems on some servers set
    up in certain ways, it is time to change your server if the problem can
    not be corrected. I had to do nothing special on the Unix (Apache)
    server I have my 2 domains on that is owned by a large international
    hosting company that can provide you with either Unix and Microsoft
    servers that you can configure in a huge number of ways. Of course
    exponential notation long has been standard in the physical sciences.

    I saw your FAQs long ago. If you look at my code, you will see that I
    blocked NN4 by checking for support of document .layers. Since even
    Netscape quit layers support with their 6 browser, using
    document.layers is good enough. I did mention checking for
    document.getElementById support to block IE4, if that ever seems
    needed. This of course would block earlier IE browsers. If you wanted
    to include the old MSNTV, you can be certain you have one of these
    beasts by checking navigator.appCodeName. This returns "bowser" in
    contrast to "Mozilla" you get on most modern browsers. Detection of a
    specific Browser sometimes is necessary when a certain browser has a
    bug. For example, Opera has a bug for some script used for controlling
    media players. You need to use a different code to play the media on
    Opera. Navigator.appName is usless because Opera can be set to spoof
    several other browsers here. Old MSNTV boxes spoofed IE4, etc. However,
    for Opera, you can scan the user agent for the string "Opera". This
    seems to be accurate for all recent browsers I have checked. Thus you
    need to start detecting what a browser can do, but in rare cases you
    may need to know what browsers you are dealing with - especially to get
    around bugs. You have to test new versions of browsers as they are
    released to make sure nothing has been changed, or if the bug has gone
    away and now needs no correction.

    I now have another page for an application of the functions in my first
    post at http://www.cwdjr.net/math/cylinderAbsorption.html . The results
    are in good agreement with the origanal calculations made many years
    ago on an IBM 370 using Fortran 4, H-level, the results of which were
    published in an internatonal peer reviewed journal.
     
    , Jun 22, 2005
    #3
  4. JRS: In article <>
    , dated Tue, 21 Jun 2005 22:02:57, seen in news:comp.lang.javascript,
    <> posted :
    >
    >The page is set up to reject the NN 4 series, because it will not
    >support some of the script needed such as .toExponential(n) and
    >to.Fixed(n)for writing output in exponential or fixed format.


    It should not be difficult to emulate the part of their functionality
    that you probably need; for example, if a Number is multiplied by 1E150
    and converted to String, it will be exponential; then split off the
    exponent, subtract 150 from it, and restore. Untested.

    For fixed format, read the newsgroup FAQ.

    --
    © John Stockton, Surrey, UK. ?@merlyn.demon.co.uk Turnpike v4.00 IE 4 ©
    <URL:http://www.jibbering.com/faq/> JL/RC: FAQ of news:comp.lang.javascript
    <URL:http://www.merlyn.demon.co.uk/js-index.htm> jscr maths, dates, sources.
    <URL:http://www.merlyn.demon.co.uk/> TP/BP/Delphi/jscr/&c, FAQ items, links.
     
    Dr John Stockton, Jun 22, 2005
    #4
  5. On 22/06/2005 22:14, wrote:

    Please learn to post properly.

    > Michael Winter replied:


    [OP:]
    >>> Javascript has a very small math function list. [...]

    >>
    >> Have you considered the fact that a large selection of such
    >> functions would go largely unused, and therefore be a waste of time
    >> and resources to implement and expose?

    >
    > There is every benefit to adding at least 20 more standard browser
    > Math objects.


    Perhaps you should read that again: those methods would go largely
    unused and wouldn't be worth the effort of implementation in most cases,
    /especially/ if they are easily created in user code.

    In my opinion, a Web scripting language should focus on the features
    necessary to script Web documents. The core language shouldn't be
    bloated with unnecessary features. Host specific implementations can add
    what they like, but such extensions shouldn't become a required feature.

    Anyway, what exactly is the point of posting this rant here? What do you
    expect us to do about it?

    [snip]

    >> Implementations of both [Number.prototype.toExponential and
    >> toFixed] are bug-ridden in some hosts.

    >
    > If what you mean is that implementation of .toExponential and
    > .toFixed has bugs in some hosts is that there are problems on some
    > servers set up in certain ways, it is time to change your server if
    > the problem can not be corrected.


    I couldn't recall which hosts were affected at the time of writing, so I
    decided to be non-specific. It would seem that JScript is the main concern.

    [snip]

    >> You would be better off blocking browsers based on what they do, or do
    >> not, support, not on unrelated features. See
    >> <URL:http://www.jibbering.com/faq/#­FAQ4_26> and its links.

    >
    > I saw your FAQs long ago. If you look at my code, you will see that I
    > blocked NN4 by checking for support of document .layers.


    So? Omniweb also implements the layers collection. Others might, too.
    Browser detection is flawed, plain and simple.

    [snip]

    > Detection of a specific Browser sometimes is necessary when a certain
    > browser has a bug.


    Not necessarily. Many bugs can be pre-empted by developing a test case
    that catches erroneous behaviour.

    [snip]

    > You have to test new versions of browsers as they are
    > released to make sure nothing has been changed, or if the bug has gone
    > away and now needs no correction.


    Which is why feature detection is far superior: it automatically
    responds to that situation.

    [snip]

    Mike

    --
    Michael Winter
    Replace ".invalid" with ".uk" to reply by e-mail.
     
    Michael Winter, Jun 23, 2005
    #5
  6. JRS: In article <O8mue.54853$>,
    dated Wed, 22 Jun 2005 23:05:18, seen in news:comp.lang.javascript,
    Michael Winter <> posted :
    >
    >Perhaps you should read that again: those methods would go largely
    >unused and wouldn't be worth the effort of implementation in most cases,
    >/especially/ if they are easily created in user code.
    >
    >In my opinion, a Web scripting language should focus on the features
    >necessary to script Web documents. The core language shouldn't be
    >bloated with unnecessary features. Host specific implementations can add
    >what they like, but such extensions shouldn't become a required feature.



    ISTM that you may be overestimating the OP's ability to express himself
    accurately in English; he or she is likely to be a foreigner, after all,
    probably not even European.

    You are right in saying that the core language should not be extended
    with obscure maths functions. However, the set provided is not large,
    and the code needed to implement a few more would not be large; the
    burden would be mainly documentational. By "a few" I mean maybe to
    include all six prime trig functions, their inverses, and the
    corresponding hyperbolics; factorial, combination, permutation, and not
    a lot more.

    It would be of use (though not necessarily worthwhile) to have a
    professional-quality library of more advanced maths (and other)
    functions, assembled in such a manner that those needed for a particular
    task could be copied for use as Methods or Functions.

    But, to be trustworthy, they'd need to be maintained and hosted by a
    reputable academic-class institution; not by some anonymous self-
    assessed whizz-kid.

    --
    © John Stockton, Surrey, UK. ?@merlyn.demon.co.uk Turnpike v4.00 IE 4 ©
    <URL:http://www.jibbering.com/faq/> JL/RC: FAQ of news:comp.lang.javascript
    <URL:http://www.merlyn.demon.co.uk/js-index.htm> jscr maths, dates, sources.
    <URL:http://www.merlyn.demon.co.uk/> TP/BP/Delphi/jscr/&c, FAQ items, links.
     
    Dr John Stockton, Jun 23, 2005
    #6
  7. fox Guest

    ..
    >
    > There is every benefit to adding at least 20 more standard browser Math
    > objects. The standard hyperbolic and other functions that are used by
    > even high school students are very easy to add. This should cost very
    > little to do.


    adding hyperbolic functions to the current set would actually be an
    exellent exercise for students to implement.

    it is not the job of language designers to provide all the specific
    tools programmers will ever need, it it their job to provide the most
    basic set of tools upon which programmers can build.

    anyway, the formula for hyperbolic transcendentals are easy to find and
    just as easy to implement:


    Math.sinh = function(x)
    {
    with(Math)
    return (exp(x) - exp(-x))/2;
    }

    Math.asinh = function(x)
    {
    with(Math)
    return log(x + sqrt(1 + x * x));
    }

    Math.cosh = function(x)
    {
    with(Math)
    return (exp(x) + exp(-x))/2;
    }

    Math.acosh = function(x)
    {
    with(Math)
    return log(x + sqrt(x * x - 1));
    }

    Math.tanh = function(x)
    {
    with(Math)
    return sinh(x)/cosh(x);
    }

    Math.atanh = function(x)
    {
    with(Math)
    return 0.5 * log((1 + x)/(1 - x));
    }

    Math.coth = function(x)
    {
    with(Math)
    return 1/tanh(x);
    }

    Math.acoth = function(x)
    {
    with(Math)
    return 0.5 * log((x + 1)/(x - 1));
    }

    Math.sech = function(x)
    {
    with(Math)
    return 1/cosh(x);
    }

    Math.asech = function(x)
    {
    with(Math)
    return log((1 + sqrt(1 - x * x))/ x );

    }

    Math.csch = function(x)
    {
    with(Math)
    return 1/sinh(x);
    }

    Math.acsch = function(x)
    {
    with(Math)
    return log((1 + (x < 0 ? -1 : 1) * sqrt(1 + x * x))/ x );
    // if i understood the domains correctly
    }

    Math.versinh = function(x)
    {
    with(Math)
    return 1 - cosh(x);
    }

    Math.haversinh = function(x)
    {
    with(Math)
    return (1 - cosh(x))/2;
    // or -(sinh(x/2))*(sinh(x/2));
    // or versinh(x)/2;
    }



    Division by zero in JS is "Infinity"...



    The "telling" feature of every added hyberbolic function above is
    "with(Math)" (everything you *need* is already there) and all that is
    used is exp, log, sqrt, and/or one of the other methods being defined.
    There is really nothing here complicated enough to merit having the
    functions predefined in the Math object.
     
    fox, Jun 24, 2005
    #7
  8. Guest

    fox wrote:
    > .
    > >
    > > There is every benefit to adding at least 20 more standard browser Math
    > > objects. The standard hyperbolic and other functions that are used by
    > > even high school students are very easy to add. This should cost very
    > > little to do.

    >
    > adding hyperbolic functions to the current set would actually be an
    > exellent exercise for students to implement.
    >
    > it is not the job of language designers to provide all the specific
    > tools programmers will ever need, it it their job to provide the most
    > basic set of tools upon which programmers can build.
    >
    > anyway, the formula for hyperbolic transcendentals are easy to find and
    > just as easy to implement:


    I guess people such as myself with a physical science background
    consider much more math basic than a businessman, for example. Anyway
    it would not be difficult to add many more math functions to basic math
    and would not require enough additional memory to matter these days. It
    is a matter of convenience for the less complicated functions.

    I have about 36 additional functions ranging from the trivial to the
    complex now. I found some on the web, I modified others from Fortran
    programs, and I wrote some of my own. At least for a limited time, you
    may view them at my site. Credit is given when the code comes from the
    web, so you can check the sites from which I obtained the code. Not all
    of these functions have been well tested, and there could have been
    mistakes in the copy to the web page. This is a work in progress.
    Please note that all of these functions are used as is. Do not use
    Math. before them. They work either within a with (Math){blah blah}
    section or without one. If I ever get time, I am going to write the
    basic JS math functions without the .Math so you just have to use
    sin(x), etc without anything else. From my background, I can not see
    why the Math. was included. It is just a bother, any anyone with a high
    school education should know what the basic math functions mean and not
    use them for something else. Perhaps they considered that elementary
    school students might write script before they had much math.

    See http://www.cwdjr.net/mathExtra/ , which contains 4 pages. The
    external javascript file containing all of the functions can be linked
    to, at least for a while, so it is easy to check some of the functions
    without downloading the JS external file. There also is a text file of
    the scripts. Another brief text file lists the functions and has a
    brief comment. A html feedback form is provided in case you wish to
    send me a comment.
     
    , Jun 24, 2005
    #8
  9. fox Guest

    wrote:
    >
    > fox wrote:
    >
    >>.
    >>
    >>>There is every benefit to adding at least 20 more standard browser Math
    >>> objects. The standard hyperbolic and other functions that are used by
    >>>even high school students are very easy to add. This should cost very
    >>>little to do.

    >>
    >>adding hyperbolic functions to the current set would actually be an
    >>exellent exercise for students to implement.
    >>
    >>it is not the job of language designers to provide all the specific
    >>tools programmers will ever need, it it their job to provide the most
    >>basic set of tools upon which programmers can build.
    >>
    >>anyway, the formula for hyperbolic transcendentals are easy to find and
    >>just as easy to implement:

    >
    >
    > I guess people such as myself with a physical science background
    > consider much more math basic than a businessman, for example.


    > Anyway
    > it would not be difficult to add many more math functions to basic math
    > and would not require enough additional memory to matter these days. It
    > is a matter of convenience for the less complicated functions.
    >
    > I have about 36 additional functions ranging from the trivial to the
    > complex now. I found some on the web, I modified others from Fortran
    > programs, and I wrote some of my own. At least for a limited time, you
    > may view them at my site. Credit is given when the code comes from the
    > web, so you can check the sites from which I obtained the code. Not all
    > of these functions have been well tested, and there could have been
    > mistakes in the copy to the web page. This is a work in progress.
    > Please note that all of these functions are used as is. Do not use
    > Math. before them. They work either within a with (Math){blah blah}
    > section or without one. If I ever get time, I am going to write the
    > basic JS math functions without the .Math so you just have to use
    > sin(x), etc without anything else. From my background, I can not see
    > why the Math. was included. It is just a bother, any anyone with a high
    > school education should know what the basic math functions mean and not
    > use them for something else. Perhaps they considered that elementary
    > school students might write script before they had much math.
    >
    > See http://www.cwdjr.net/mathExtra/ , which contains 4 pages. The
    > external javascript file containing all of the functions can be linked
    > to, at least for a while, so it is easy to check some of the functions
    > without downloading the JS external file. There also is a text file of
    > the scripts. Another brief text file lists the functions and has a
    > brief comment. A html feedback form is provided in case you wish to
    > send me a comment.
    >


    Thank you for these -- I am particularly interested in the Bessel
    functions...
     
    fox, Jun 24, 2005
    #9
  10. Paul Cooper Guest

    On Thu, 23 Jun 2005 21:27:12 -0500, fox <>
    wrote:

    >.
    >>
    >> There is every benefit to adding at least 20 more standard browser Math
    >> objects. The standard hyperbolic and other functions that are used by
    >> even high school students are very easy to add. This should cost very
    >> little to do.

    >
    >adding hyperbolic functions to the current set would actually be an
    >exellent exercise for students to implement.
    >
    >it is not the job of language designers to provide all the specific
    >tools programmers will ever need, it it their job to provide the most
    >basic set of tools upon which programmers can build.
    >
    >anyway, the formula for hyperbolic transcendentals are easy to find and
    >just as easy to implement:
    >

    SNIP
    >
    >The "telling" feature of every added hyberbolic function above is
    >"with(Math)" (everything you *need* is already there) and all that is
    >used is exp, log, sqrt, and/or one of the other methods being defined.
    >There is really nothing here complicated enough to merit having the
    >functions predefined in the Math object.
    >



    I am afraid you have just illustrated the point that John Stockton
    made - that it isn't as easy as that. Your functions will fail
    interestingly and undetectably in many cases - some could end up
    returning the result of taking the difference of two numbers very
    close in value, for example. The loss of precision would make the
    results meaningless. And of course, some may return the result of
    dividing a very large number by a very small number - again, with
    results depending on the behaviour of the floating point engine. Of
    course, the divide by zero error you mention will be caught, but other
    situations which result in disastrous loss of precision won't be.

    The text-book formulae are in most cases designed to illustrate the
    properties and derivation of the function, and are not a practical
    means of computing it reliably. Practical implementations have to take
    into account the problems of working with digital arithmetic, provide
    proper exception handling and guaranteed precision. That is why John
    Stockton suggested that creating and maintaining such a library was a
    task for a Mathematics or Computer Science group, not for an
    individual. I wouldn't take it on, and I am used to complex
    trigonometrical calculations.

    Paul
     
    Paul Cooper, Jun 24, 2005
    #10
  11. JRS: In article <>, dated
    Fri, 24 Jun 2005 09:22:17, seen in news:comp.lang.javascript, Paul
    Cooper <> posted :
    >
    >I am afraid you have just illustrated the point that John Stockton
    >made - that it isn't as easy as that. Your functions will fail
    >interestingly and undetectably in many cases - some could end up
    >returning the result of taking the difference of two numbers very
    >close in value, for example. The loss of precision would make the
    >results meaningless. And of course, some may return the result of
    >dividing a very large number by a very small number - again, with
    >results depending on the behaviour of the floating point engine. Of
    >course, the divide by zero error you mention will be caught, but other
    >situations which result in disastrous loss of precision won't be.
    >
    >The text-book formulae are in most cases designed to illustrate the
    >properties and derivation of the function, and are not a practical
    >means of computing it reliably. Practical implementations have to take
    >into account the problems of working with digital arithmetic, provide
    >proper exception handling and guaranteed precision. That is why John
    >Stockton suggested that creating and maintaining such a library was a
    >task for a Mathematics or Computer Science group, not for an
    >individual. I wouldn't take it on, and I am used to complex
    >trigonometrical calculations.



    Indeed. To illustrate : this expression is from the Help of several
    versions of a widely-sold compiler family (not necessarily the latest
    versions) :
    ArcCos(x) = ArcTan (sqrt (1-sqr (x)) /x)

    It is trigonometrically correct.

    However, ArcTan always returns an angle within -90 to +90, whereas a
    positive argument for ArcCos should return one of two values in that
    range and a negative argument for ArcCos should return one of two values
    in the other half of the circle.

    They forgot that every positive real number has two square roots of
    opposite sign, and that it is always necessary to choose the appropriate
    one; whereas in that language sqrt, like Math.sqrt, always gives a non-
    negative result.

    The expression is computationally incorrect; other trigonometrical
    expressions are also computationally correct.


    I vaguely recall that ATAN2 may be better than ATAN as a primitive.



    It could be possible to extend the Math object with bolt-on native code;
    that would potentially be better, by allowing direct use of the FPU.


    I can't recall whether I said this before, but I lived for a year at #54
    of the road by which you work, if you are housed in SPRI.

    --
    © John Stockton, Surrey, UK. ?@merlyn.demon.co.uk Turnpike v4.00 IE 4 ©
    <URL:http://www.jibbering.com/faq/> JL/RC: FAQ of news:comp.lang.javascript
    <URL:http://www.merlyn.demon.co.uk/js-index.htm> jscr maths, dates, sources.
    <URL:http://www.merlyn.demon.co.uk/> TP/BP/Delphi/jscr/&c, FAQ items, links.
     
    Dr John Stockton, Jun 24, 2005
    #11
  12. Guest

    Paul Cooper wrote:
    Practical implementations have to take
    > into account the problems of working with digital arithmetic, provide
    > proper exception handling and guaranteed precision.


    There are many good programs written in Fortran and C++ as well as many
    long discarded languages for evaluating the more common math functions.
    These have built in checks and warning messages in many cases.These
    programs often are fairly easy to adapt to JS. However one does not
    always want the highest precision. In fact, if one is calculating math
    functions within a deep nest, you need to use the least precision
    possible for the problem to speed up very long calculations. This of
    course requires a detailed analysis of the system at hand. Mathematica
    5.1, for example, will allow you to select the number of places needed
    for a function output.

    If you are wanting to do math on the computer, and not the web, of
    course you need to add C++, Fortran, or other higher level language
    support, or you may be able to get by with Mathematica or something of
    the sort. Unfortunately Mathematica 5.1 costs about $US1800 new,
    although Amazon is now having a sale in the $1500 range. This is too
    high a price for many indivaduals, although reduced rates are available
    for students. There also is an expensive version of Mathematica you can
    put on your server. However, here you must be very careful if you do
    not have use of an entire server. Some math operations can use a huge
    amount of server capacity. On a shared server, there often are
    restrictions on the maximum percentage of capacity you can use at any
    time. Exceeding this limit can result in huge bills or disconnection
    until you resolve the problem. At least this is the way my domain host
    works.

    There is a free program, Dataplot, available from the NIST, the US
    government standards organization, known as the NBS(National Bureau of
    Standards) until fairly recently. See
    http://www.itl.nist.gov/div898/software/dataplot/ . This is written in
    Fortran, but compiled and ready to use on many different PC platforms
    without adding a Fortran compiler. This program will evaluate a huge
    number of even very uncommon functions. It will plot and display these
    functions, or results for equations using functions. It will accept
    input data and curve fit and do statistical analysis. The range of
    types of statistical analysis is huge. I have found this program very
    useful. It also can be installed on a server. Dataplot may not be as
    fancy and do as many things as some of the expensive commercial
    programs, but it does many things as well as many people need. It is
    nice to have around when you want to check math you are doing using JS
    for the web. I also believe the program is free to foreigners,
    including the British, even though they are not US tax payers who
    support the government organizations :). I have had a little contact
    with the NIST in the past and have been impressed by the quality of
    most of their work. Unfortunately they have a very restricted budget
    these days. Also the Nobel committee has been well impressed with the
    quility of some of their work.
     
    , Jun 25, 2005
    #12
  13. fox Guest

    Paul Cooper wrote:
    > On Thu, 23 Jun 2005 21:27:12 -0500, fox <>
    > wrote:
    >
    >
    >>.
    >>
    >>>There is every benefit to adding at least 20 more standard browser Math
    >>> objects. The standard hyperbolic and other functions that are used by
    >>>even high school students are very easy to add. This should cost very
    >>>little to do.

    >>
    >>adding hyperbolic functions to the current set would actually be an
    >>exellent exercise for students to implement.
    >>
    >>it is not the job of language designers to provide all the specific
    >>tools programmers will ever need, it it their job to provide the most
    >>basic set of tools upon which programmers can build.
    >>
    >>anyway, the formula for hyperbolic transcendentals are easy to find and
    >>just as easy to implement:
    >>

    >
    > SNIP
    >
    >>The "telling" feature of every added hyberbolic function above is
    >>"with(Math)" (everything you *need* is already there) and all that is
    >>used is exp, log, sqrt, and/or one of the other methods being defined.
    >>There is really nothing here complicated enough to merit having the
    >>functions predefined in the Math object.
    >>

    >
    >
    >
    > I am afraid you have just illustrated the point that John Stockton
    > made - that it isn't as easy as that.


    Actually, 1) I didn't *illustrate* ANYTHING of the sort, and 2) it IS as
    easy as that... do you think that if these functions were implemented in
    the native math package, they would be implemented differently than
    this? JavaScript wasn't designed for mathmaticians or scientists... it
    is a "general purpose" *scripting* language...

    Besides, the *point* of my original response was *not* the functions
    themselves, but the method of extending the Math package and how easily
    accomplished it actually is. If practical implementations are important
    to you, why don't you submit them here... instead of *just talking about
    it*.

    > Your functions will fail
    > interestingly and undetectably in many cases - some could end up
    > returning the result of taking the difference of two numbers very
    > close in value, for example. The loss of precision would make the
    > results meaningless. And of course, some may return the result of
    > dividing a very large number by a very small number - again, with
    > results depending on the behaviour of the floating point engine. Of
    > course, the divide by zero error you mention will be caught, but other
    > situations which result in disastrous loss of precision won't be.


    Show me... then show me how any of it is different than what already
    exists in the Math package. Show me in terms of a "normal" program that
    somebody would need for an application, and not some kind of contrived
    "special case" designed to break it.

    The JS FP "engine" is quite robust... 64 bit ieee754 (if ecma compliant)
    .... reports NaNs and Infinities... gradual underflow... fairly unbreakable.

    BTW -- what is a "disastrous loss of precision?" I've been programming
    over 23 years now, and I've never heard of this...

    >
    > The text-book formulae are in most cases designed to illustrate the
    > properties and derivation of the function, and are not a practical
    > means of computing it reliably.


    I would contend that such derived functions (the "longer versions" being
    "proofs") *are* a means of computing them reliably. The definitions did
    not state "approximately equal to" -- they are as stated.


    Practically speaking, from a programmer's point of view: the "extended"
    Math functions/methods use already natively-provided functions and very
    little overhead...i.e.: they won't slow you down much.

    I don't think there are very many people around who would be patient
    enough for a scripting language like JavaScript to evaluate Taylor's
    Series Expansions and the like to achieve a "precise" value of any of
    these functions. (and considering these series tend to "oscillate"
    across a limit as they approach it, stopping the evaluation at
    arbitrarily shorter terms to save time and/or execution overhead could
    render the result MORE imprecise than using exponentials and logs.)

    > Practical implementations have to take
    > into account the problems of working with digital arithmetic, provide
    > proper exception handling and guaranteed precision. That is why John
    > Stockton suggested that creating and maintaining such a library was a
    > task for a Mathematics or Computer Science group, not for an



    this is almost hysterical... talk about overkill. What would they call it?

    Applied Numerics And Logic group?

    >


    "Guaranteed precision" (whatever that is) is not a feature of the Math
    package... never has been. Considering the precision we do have in Math,
    if you implement precision handling within the methods themselves, you
    take it out of the hands of the programmers who would not ordinarily
    require it and slowing down operations for everybody across the board.
    Programmers are responsible for handling ranges and precisions in and
    out of the basic functions... this sort of thing does not belong inside
    general purpose functions.


    If you need to use a *browser* for "guaranteed precision", use Netscape
    and load the java.math package for arbitrary-precision math:

    if(navigator.appName.indexOf("Netscape") != -1)
    // doomed to fail if spoofed
    // also, java support in v6 was "interrupted"
    // so this may or may not work in NN6
    {

    var BD = java.math.BigDecimal;

    var somedecimal_1 =
    new BD("12340.0000000000000000000000000000001");


    var somedecimal_2 =
    new BD("12340.0000000000000000000000000000003");


    var sum = somedecimal_1.add(somedecimal_2);

    }

    else

    var sum = "You need a Netscape browser to use this";


    alert(sum);
    // result: 24680.0000000000000000000000000000004 exactly
    // works in NN4 and NN7/8 -- btw: that's 36 significant digits
    // more than twice what you get in javascript
    // and can have arbitrarily greater significant digits


    use strings to instantiate the BigDecimal, otherwise you run into the
    same binary -> decimal conversion problems.


    roll your own ... ...knock yourself out...

    (it will *not* be a "practical" use of your time... I can guarantee with
    remarkable precision)
     
    fox, Jun 26, 2005
    #13
  14. Paul Cooper Guest

    On Fri, 24 Jun 2005 22:54:32 +0100, Dr John Stockton
    >
    >I can't recall whether I said this before, but I lived for a year at #54
    >of the road by which you work, if you are housed in SPRI.
    >


    I used to work at SPRI from 1979-1988 after which I moved to BAS. BAS
    is located on Madingley Road, right next to the M11.

    Best wishes

    Paul
     
    Paul Cooper, Jun 27, 2005
    #14
  15. JRS: In article <d9lo1i$2jr$>, dated Sun, 26 Jun
    2005 03:12:29, seen in news:comp.lang.javascript, fox
    <> posted :
    >Paul Cooper wrote:


    >> I am afraid you have just illustrated the point that John Stockton
    >> made - that it isn't as easy as that.

    >
    >Actually, 1) I didn't *illustrate* ANYTHING of the sort, and 2) it IS as
    >easy as that... do you think that if these functions were implemented in
    >the native math package, they would be implemented differently than
    >this?


    That depends on the competence of the implementer, and on the degree of
    effort used. For example, Math.cosh would most easily, I expect, be
    provided by use of Math.exp itself; but it would more effectively be
    provided by directly calling the machine's native exp function.


    > JavaScript wasn't designed for mathmaticians or scientists... it
    >is a "general purpose" *scripting* language...


    ISTM that it was more thrown together than designed, in contrast to,
    say, Wirth's Pascal.

    Functions provided as part of the system should be implemented to full
    machine accuracy over the full range; the system provider cannot
    completely tell what the system may be used for, though he should
    understand the commoner cases.

    Remember that over 99% of javascripters will not recall cosh other than
    as an instrument of assault; those who use it will largely be doing
    technical applications, and will want correctness.



    >Besides, the *point* of my original response was *not* the functions
    >themselves, but the method of extending the Math package and how easily
    >accomplished it actually is. If practical implementations are important
    >to you, why don't you submit them here... instead of *just talking about
    >it*.


    He truly recognises the degree of effort and skill needed to do the job
    well; you do not, or do not care.


    >BTW -- what is a "disastrous loss of precision?" I've been programming
    >over 23 years now, and I've never heard of this...


    The self-taught generally have wide areas of lamentable ignorance; the
    clever ones recognise this.


    >I would contend that such derived functions (the "longer versions" being
    >"proofs") *are* a means of computing them reliably. The definitions did
    >not state "approximately equal to" -- they are as stated.


    In infinite-precision mathematics, and where speed cannot matter, yes;
    in actual implementation, no.

    Consider sinh(x), defined as (exp(x)-exp(-x)/2. Calculated that way, it
    has a 45% error at x=1E-16, and is 0 at x = 1E-17.

    A competent implementation would substitute sinh(x) = x for sufficiently
    small x, where sufficiently small seems to be reached at the 1E-5..1E-6
    region, or more likely would use a method not requiring exp itself; in
    particular, for x>=0 it would never return sinh(x)<x.


    >I don't think there are very many people around who would be patient
    >enough for a scripting language like JavaScript to evaluate Taylor's
    >Series Expansions and the like to achieve a "precise" value of any of
    >these functions. (and considering these series tend to "oscillate"
    >across a limit as they approach it, stopping the evaluation at
    >arbitrarily shorter terms to save time and/or execution overhead could
    >render the result MORE imprecise than using exponentials and logs.)


    But have you the depth of understanding required for your thought to be
    of any value?


    >> Practical implementations have to take
    >> into account the problems of working with digital arithmetic, provide
    >> proper exception handling and guaranteed precision. That is why John
    >> Stockton suggested that creating and maintaining such a library was a
    >> task for a Mathematics or Computer Science group, not for an

    >
    >
    >this is almost hysterical... talk about overkill. What would they call it?
    >
    >Applied Numerics And Logic group?


    DAMTP? not quite.

    --
    © John Stockton, Surrey, UK. ?@merlyn.demon.co.uk Turnpike v4.00 IE 4 ©
    <URL:http://www.jibbering.com/faq/> JL/RC: FAQ of news:comp.lang.javascript
    <URL:http://www.merlyn.demon.co.uk/js-index.htm> jscr maths, dates, sources.
    <URL:http://www.merlyn.demon.co.uk/> TP/BP/Delphi/jscr/&c, FAQ items, links.
     
    Dr John Stockton, Jun 27, 2005
    #15
  16. JRS: In article <>, dated
    Mon, 27 Jun 2005 11:29:41, seen in news:comp.lang.javascript, Paul
    Cooper <> posted :
    >On Fri, 24 Jun 2005 22:54:32 +0100, Dr John Stockton
    >>
    >>I can't recall whether I said this before, but I lived for a year at #54
    >>of the road by which you work, if you are housed in SPRI.
    >>

    >
    >I used to work at SPRI from 1979-1988 after which I moved to BAS. BAS
    >is located on Madingley Road, right next to the M11.


    After my time.

    Regards,

    --
    © John Stockton, Surrey, UK. *@merlyn.demon.co.uk / ?? ©
    Web <URL:http://www.merlyn.demon.co.uk/> - FAQish topics, acronyms, & links.
    Correct <= 4-line sig. separator as above, a line precisely "-- " (SoRFC1036)
    Do not Mail News to me. Before a reply, quote with ">" or "> " (SoRFC1036)
     
    Dr John Stockton, Jun 27, 2005
    #16
  17. fox Guest

    Dr John Stockton wrote:
    > JRS: In article <d9lo1i$2jr$>, dated Sun, 26 Jun


    >
    > That depends on the competence of the implementer, and on the degree of
    > effort used...
    >
    > He truly recognises the degree of effort and skill needed to do the job
    > well; you do not, or do not care.


    > The self-taught generally have wide areas of lamentable ignorance; the
    > clever ones recognise this.


    > A competent implementation ...
    >
    > But have you the depth of understanding required for your thought to be
    > of any value?


    You are entitled to your opinion. Somewhat harsh... but maybe you're right.

    I have a "little" program I wrote about five or six years ago and I'm
    have a section of code I could use your help with (actually not entirely
    off-topic...quite a lot of "extended math functions" technically
    reapplied to the Number object though)...it's *right up your alley.* It
    involves physics and perhaps you're right, a mere programmer is not
    capable of the understanding required. [haven't had the time to revisit
    it since so the gui I planned never materialized-- it's very bare bones
    -- not "cluttered".]

    It should be really simple to read... after all, I wrote it *for* myself.

    If you find yourself wondering: I attached the methods to the Number
    object so I could easily follow along with Meeus' book: Astronomical
    Algorithms. Extra PI precision (in places) because this was supposed to
    be ported to Java later. Originally started out with "classic" orbital
    elements then converted to vsop.

    The main Object is "Planet()" [index page] instantiated from "handleClick"

    For my application, I do not need better precision than to the nearest
    arcminute (although arcseconds would definitely be preferable... but
    hey! this is me we're talking about) compared to the ephemerides of JPL
    or the like for "apparent geocentric" coordinates and the output is in
    terms of Zodiacal position (longitude -- just converting degrees to
    something familiar).

    ....I'm having a little problem with Pluto (up to +/- 5 arcmins off), and
    perhaps you could see where my errors are:

    http://fxmahoney.com/demo/astro/

    Pluto specific routines are at the bottom of the vsop.js file (before
    the moon routines).

    [recommend Courier New (8pt, if possible) used as font for viewing source]

    I really would appreciate your help. You *are* the doctor.
     
    fox, Jun 29, 2005
    #17
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. chirs
    Replies:
    18
    Views:
    800
    Chris Uppal
    Mar 2, 2004
  2. AciD_X
    Replies:
    4
    Views:
    8,180
    Jonathan Turkanis
    Apr 1, 2004
  3. Mark Healey
    Replies:
    7
    Views:
    1,570
    Tim Prince
    May 22, 2006
  4. Philipp
    Replies:
    9
    Views:
    1,175
    Mark Space
    Jul 23, 2008
  5. VK
    Replies:
    15
    Views:
    1,332
    Dr J R Stockton
    May 2, 2010
Loading...

Share This Page