XProfan

Français

p.specht

qui ArcusSinus, il vient u.a. dans Ellipsenformeln avant, liefert entre den Argumentwerten -1 et 1 qui renversement qui Sinusfunktion, bien sûr seulement sur den ersten Wellenzug bezogen. si wir ihm dire, combien % einer vollen Umdrehung gelaufen ist, partie il uns en supplément qui Bogenlänge sur dem Einheitskreis dans Radiantmetern [roue] avec (lat. arcus est oui 'Bogen').

une Erfindung des Herrn Taylor erlaubt es, so assez chacun mehrfach ableitbare Funktion dans un "unendliche" Reihe trop entwickeln, qui ordinateur relativ vite berechnen peut. pas toujours erreicht on dabei qui geforderte Genauigkeit, weil: Irgendwo muss qui Reihe dans qui réalité oui démolir. aussi gibt es verschiedene Reihen, qui unterschiedlich bien approprié sommes. Einen Test qui Standard-Reihenentwicklung um den Punkt 0 herum sieht on suivante, beschleunigbar wäre cela Ganze aussi encore deutlich...

Kompilieren Marque Séparation

Titre de la fenêtre "Test einer Eigenbau-ArcusSinus(x)-Funktion"
Font 2:randomize:set("decimals",17)
Cls rnd(8^8)
imprimer "  arcsin(x) avec x=[-1.0..+1.0]: liefert qui Bogenlänge [roue] des 1.Sinus-Wellenzugs"
imprimer "  math.inc-Nachbau:      Eigenbau-TaylorArcSin(x)       Abs.faute:                       "

WhileLoop -1000,1000

    imprimer &Boucle,asin(&Boucle/1000),
    imprimer tlrasin(&Boucle/1000),format$("%e",tlrasin(&Boucle/1000)-asin(&Boucle/1000))

    si %csrlin>24:waitInput 10000:cls rnd(8^8):endif

    Wend

    WaitInput
    Fin

    proc ASIN : parameters x!' = Nachbau qui entsprechenden math.inc-Funktion

        var res!=0:var il$=»
        var xx!=x!*x!
        var wur!=1-xx!

        si wur!>=0

            wur!=sqrt(wur!)

            si wur!<>0

                res!=arctan(x!/wur!)

            d'autre

                res!=val("10^-30")
                il$="Div0 dans asin()"

            endif

        d'autre

            res!=val("-1*10^-30")
            il$="Nonreal racine dans asin()"

        endif

        imprimer il$,
        return res!

    endproc

    proc ACOS :parameters x!

        return pi()/2-ASIN(x!)

    endproc

    Proc TlrASin : parameters x!' Eigenbau-arcussinus(x) par Taylorreihe

        ' qui wahre ArcusSinus ist défini pour Argumente -1 ,,, +1.
        ' Testergebnisse pour den Nachbau;
        ' sur 5 se mettre exakt seulement +/- 0.833 um den Nulldurchgang
        ' sur 3 se mettre exakt seulement dedans +/- 0.933
        var tmp!=0:var x2!=x!*x!:var x3!=x2!*x!:var x5!=x3!*x2!:var x7!=x5!*x2!
        var x9!=x7!*x2!:var x11!=x9!*x2!:var x13!=x11!*x2!:var x15!=x13!*x2!
        var x17!=x15!*x2!:var x19!=x17!*x2!:var x21!=x19!*x2!:var x23!=x21!*x2!
        var x25!=x23!*x2!:var x27!=x25!*x2!:var x29!=x27!*x2!:var x31!=x29!*x2!
        var x33!=x31!*x2!:var x35!=x33!*x2!:var x37!=x35!*x2!:var x39!=x37!*x2!
        tmp!=tmp!+x!
        tmp!=tmp!+x3!/3 * 1/2
        tmp!=tmp!+x5!/5 * 1/2*3/4
        tmp!=tmp!+x7!/7 * 1/2*3/4*5/6
        tmp!=tmp!+x9!/9 * 1/2*3/4*5/6*7/8
        tmp!=tmp!+x11!/11 * 1/2*3/4*5/6*7/8*9/10
        tmp!=tmp!+x13!/13 * 1/2*3/4*5/6*7/8*9/10*11/12
        tmp!=tmp!+x15!/15 * 1/2*3/4*5/6*7/8*9/10*11/12*13/14
        tmp!=tmp!+x17!/17 * 1/2*3/4*5/6*7/8*9/10*11/12*13/14*15/16
        tmp!=tmp!+x19!/19 * 1/2*3/4*5/6*7/8*9/10*11/12*13/14*15/16*17/18
        tmp!=tmp!+x21!/21 * 1/2*3/4*5/6*7/8*9/10*11/12*13/14*15/16*17/18*19/20
        tmp!=tmp!+x23!/23 * 1/2*3/4*5/6*7/8*9/10*11/12*13/14*15/16*17/18*19/20*21/22
        tmp!=tmp!+x25!/25 * 1/2*3/4*5/6*7/8*9/10*11/12*13/14*15/16*17/18*19/20*21/22*23/24
        tmp!=tmp!+x27!/27 * 1/2*3/4*5/6*7/8*9/10*11/12*13/14*15/16*17/18*19/20*21/22*23/24*25/26
        tmp!=tmp!+x29!/29 * 1/2*3/4*5/6*7/8*9/10*11/12*13/14*15/16*17/18*19/20*21/22*23/24*25/26*27/28
        tmp!=tmp!+x31!/31 * 1/2*3/4*5/6*7/8*9/10*11/12*13/14*15/16*17/18*19/20*21/22*23/24*25/26*27/28*29/30
        tmp!=tmp!+x33!/33 * 1/2*3/4*5/6*7/8*9/10*11/12*13/14*15/16*17/18*19/20*21/22*23/24*25/26*27/28*29/30*31/32
        tmp!=tmp!+x35!/35 * 1/2*3/4*5/6*7/8*9/10*11/12*13/14*15/16*17/18*19/20*21/22*23/24*25/26*27/28*29/30*31/32*33/34
        tmp!=tmp!+x37!/37 * 1/2*3/4*5/6*7/8*9/10*11/12*13/14*15/16*17/18*19/20*21/22*23/24*25/26*27/28*29/30*31/32*33/34*35/36
        tmp!=tmp!+x39!/39 * 1/2*3/4*5/6*7/8*9/10*11/12*13/14*15/16*17/18*19/20*21/22*23/24*25/26*27/28*29/30*31/32*33/34*35/36*37/38
        return tmp!

    ENDPROC

XProfan 11
Computer: Gerät, daß es in Mikrosekunden erlaubt, 50.000 Fehler zu machen, zB 'daß' statt 'das'...

07.05.2021 ▲

Vollständiges citation

Absatzweise Citation Zeilenweise Citation

p.specht

und dir mais aussi anders:

ArcSin iterativ ermitteln
==================
Dass on sich sur une Iteration einer Quadratwurzel-Formel qui Umkehrfunktion des SINUS presque beliebig annähern peux, wird im folgenden Programme demonstriert. il y a oui z.B. Situationen, wohin on cela einem Microprozessor beibringen voudrais.

Kompilieren Marque Séparation

Titre de la fenêtre "ArcSin per Iteration"
'From Pascal (by J.P.Moreau) to XProfan-11 by P.Specht/Vienna
'********************************************************
'*       Program to demonstrate arcsine Iteration       *
'* ---------------------------------------------------- *
'*   Reference: BASIC Scientific Subroutines, Vol. II   *
'*   by F.R. Ruckdeschel, BYTE/McGRAWW-HILL, 1981 [1].  *
'* ---------------------------------------------------- *
'* SAMPLE RUN:                                          *
'*   X       ARCSIN(X)       STEPS        ERROR         *
'*  -----------------------------------------------     *
'*  0.00     0.0000000         0       0.0000000000     *
'*  0.05     0.0500209         7      -0.0000000013     *
'*  0.10     0.1001674         8      -0.0000000025     *
'*  0.15     0.1505683         9      -0.0000000021     *
'*  0.20     0.2013579        10      -0.0000000013     *
'*  0.25     0.2526803        10      -0.0000000025     *
'*  0.30     0.3046927        11      -0.0000000011     *
'*  0.35     0.3575711        11      -0.0000000017     *
'*  0.40     0.4115168        11      -0.0000000025     *
'*  0.45     0.4667653        12      -0.0000000009     *
'*  0.50     0.5235988        12      -0.0000000012     *
'*  0.55     0.5823642        12      -0.0000000016     *
'*  0.60     0.6435011        12      -0.0000000021     *
'*  0.65     0.7075844        13      -0.0000000007     *
'*  0.70     0.7753975        13      -0.0000000008     *
'*  0.75     0.8480621        13      -0.0000000010     *
'*  0.80     0.9272952        13      -0.0000000012     *
'*  0.85     1.0159853        13      -0.0000000014     *
'*  0.90     1.1197695        14      -0.0000000004     *
'*  0.95     1.2532359        14      -0.0000000004     *
'*  1.00     1.5707963         0       0.0000000000     *
'********************************************************
Fenêtre Style 24:Cls:font 2:set("decimals",8)
Déclarer e!,x!,i&,m&,y!,pi!,u0!,u1!,u2!
imprimer "\n X      ArcSinIter(X)       STEPS     ERROR"
imprimer "-------------------------------------------------------------------"
e!=val("1e-15")
x!=0

whileloop 1,21:i&=&Boucle

    y!=ArcSinIter(x!)
    imprimer " ";format$("#0.00",x!),tab(9);format$("%g",y!),\
    tab(29);m&,tab(34);format$("%g",sin(y!)-x!)
    x!=x!+0.05

Endwhile

imprimer
beep:Waitinput
Fin

Proc ArcSinIter :parameters x!

    '************************************************
    '*       Arcsin(x) recursion subroutine         *
    '* Contribution is x (-1<x<1), output is y=arcsin(x),  *
    '* convergence criteria is e.                   *
    '* -------------------------------------------- *
    '* Reference: Computational Analysis by Henrici *
    '************************************************
    m&=0
    pi!=Pi()
    cas e!<0:return y!'Guard against failure
    cas x!<>0:y!=Check_range(x!)
    return y!

ENDPROC

Proc Check_range :parameters x!

    cas abs(x!)>=1:goto "G1300"
    u0!=x!*sqrt(1-x!*x!)
    u1!=x!

    Repeat

        u2!=u1!*sqrt(2*u1!/(u1!+u0!))
        y!=u2!
        m&=m&+1
        cas abs(u2!-u1!)<e!:BREAK
        u0!=u1!:u1!=u2!

    Until 0

    G1300:
    cas abs(x!-1)<val("1e-10"):y!=pi!/2
    return y!

ENDPROC

'Fin of file ArcsinIter.prf