Der Nachfolger des WDR-Computerclub mit Wolfgang Back und Wolfgang Rudolph - ...und immer ein Bit übrigbehalten!


Das Forum zur C-Control-1
Welche C-Control-Varianten existieren?
Übersicht - Suchen - Neueste 50 Beiträge - Neuer Beitrag - Login - Registrieren
INFO - FAQ - CC2-Forum - CCPro-Forum 

 Re: Quadratwurzel von 32 Bit Zahl Kategorie: Open-Micro/Open-Mini/Open-Midi/Open-Macro/Open-Maxi (von GeKue - 29.01.2015 12:39)
 Als Antwort auf Re: Quadratwurzel von 32 Bit Zahl von Joe - 9.01.2015 9:53
Hallo Joe,
anbei das Versprochene. Habe aus Zeitgründen das Fehlerprogramm nicht durchlaufen lassen. Sollten noch Fehler auftauchen, bitte melden. Dietmar hat auch meine Email-Adresse...

         '  Quadratwurzel :Januar 2015 => GeKue, Halle/Saale
'*********************************************************************************************
'   Während schon die Babyloner vor ca 4000 Jahren das Ziehen aus Quadratwurzeln mittels Annäherung (mehrfache
'   Annäherung an das Produktpaar (A+x)*(A+y) durch sinnvolle Änderung von x und y mittels Multiplikation
'   und Division beherrschten, nutzen 8 Bit Rechner wohl meist die Vorteile des schriftlichen Wurzelziehens
'   binärer Zahlen. Das Verfahren beruht auf der Zerlegung einer Quadratzahl A mittels binomischer Formel A^2=(a+b)^2
'   in die Summe a+b. Besteht die Zahl A aus mehreren Ziffern (Zx), wird durch sich wiederholende Rechnungen, von der
'   größten Ziffer beginnend, jede einzelne Ziffer durch Rechnung ermittelt. Bei Binärzahlen kann jede ermittelte
'   Ziffer nur ein 0 oder 1 sein. Weiterhin muß die ermittelte Zahl A mit einer 1 beginnen, Z1 muß also eine 1 sein.
'   Eine Quadratzahl läßt sich bestehend aus aufeinanderfolgenden Ziffernpaaren schreiben z.B.: b10110010 > P1=10;
'   P2=11; P3=00; P4=10. Die Rechnung beginnt mit der Differenzbildung zwischen erster ermittelter Ziffer (Z1)(muß ja
'   1 sein) und dem ersten Ziffernpaar (P1). Diese Differenz (D1) ist der Startwert der sich wiederholenden Rechnung.
'   An D1 wird das nächste Ziffernpaar (P2) angehängt und so D2 gebildet.Im obigen Beispiel ist Z1=b01, P1=b10 und
'   D1=b10-b01=b01. Nun wird D1 mit P2 erweitert zu E1 erweitert (E1=b0111). Z1 wird ebenfalls um eine Stelle erweitert
'   zu Z1'=b010. Ab jetzt wird alles wiederholt, bis die Ziffernfolge ermittelt wurde.
'    Loop:
'     Jetzt wird die Differenz zwischen den beiden möglichen Quadrat-Zahlen (Z1')^2 und (Z1' +1)^2 berechnet.
'     Nach Auflösung der binomischen Formel ergibt sich als Differenz: 2Z1+1.
'     Für die Binärberechnung folgt für die Differenzbildung (D2') sehr einfach: Z1 zwei-mal mit zwei multiplizieren (
'     erstes Mal (Stelle erweitern), zweites Mal wegen "2Z1" und anschließend eine 1 zu addieren. Jetzt bleibt nur noch
'     zu schauen, ob D2'>E1 ist. Wenn > geht es sofort mit Loop weiter, wenn nicht, wird erst noch die Differenz berechnet.
'  Runden - leider konnte ich im Netz nichts über 8-Bit Rechner und Runden von Wurzeln mit Rest finden
'     aber eine einfache Lösung liegt auf der Hand: Nach dem Wurzel-ziehen einer Nicht-Quadratzahl ergibt sich ein Rest.
'     Dieser liegt zwischen dem Quadrat der ausgerechneten Quadratzahl und dem Quadrat der nächsten Quadratzahl (A+1)^2.
'     Das Quadrat einer Zahl (A) mit Nachkomma (B) kann als (A+B)^2 geschrieben werden. Ist B>=0.5 wird aufgerundet.
'     Aufgelöst folgt: (A+0.5)^2 =A^2 + A + 0.25 ; wenn der Rest also >= A+0.25 ist, wird aufgerundet. Da bei dieser
'     Berechnung keine Nachkommazahlen auftauchen, wird aufgerundet, wenn Rest> Quadratzahl ist.
'  Nachkommastellen - Auch hier konnte ich im Netz kein einfaches Verfahren für einen 8-Bit Rechner finden. Dieses Rad
'     wurde sicher vor 30 Jahren schon (sicherlich cleverer) erfunden...
'     Mein Ansatz:
'     In einem ersten Schritt werden die binären Nachkommastellen, wie die Vorkommastellen berechnet, mit dem Unterschied,
'     daß das angehängte Ziffernpaar immer "00" ist.
'     In einem zwoten Schritt müssen die binären Nachkommastellen ausgewertet werden.
'     So wie die Stellen vor dem Komma dem Faktor 2^x, entsprechen die Stellen nach dem Komma der Potenz von 2^(-x)
'     0,11111111 berechnet sich also aus der Summierung von
'     0.5+0.25=0.75+0.125=0.875+0.0625=0.9375+0,03125=0.96875+0,015625=0.984375+0.0078125=0.9921875+0.00390625=0.99609375.
'     Es ist leicht zu sehen, daß nach diesem Verfahren selbst die 8. binäre Nachkommastelle noch erheblichen Einfluß auf
'     die Größe der ersten zwei dekadischen Nachkommastellen hat.
'     In einem dritten Schritt muß bei 8 Nachkommastellen noch durch 10.000.000 dividiert werden um zu einer
'     halbwegs sinnvollen zweistelligen Nachkommazahl zu kommen.
'     Um BerechnungsZeit & Speicherplatz zu sparen, mindere ich die Summanden auf vier Nachkommastellen und runde
'     die Summanden und multipliziere mit 10000: Aus 0,11111111 wird dann
'     5000+2500=7500+1250=8750+625=9375+313=9688+156=9844+78=9922+39=9961/10.000= 0,9961 - also nur unwesentlich
'     schlechter als obiges 0.99609375.
'  Richtigkeit - angehängt ist ein Programm mit dem die Stetigkeit aufeinanerfolgender Rechnungen geprüft werden kann.
'     Sollte jemand Fehler feststellen, bitte die fehlerhafte Berechnung melden...
'  Sollte jemand bessere Alghorithmen für die OM finden, sind sicherlich alle User interessiert - also her damit...


'********************************************************************************************************
'*******************************************************************************************************
' --- Betriebssystem konfigurieren ------------------------------------------
          'INCLUDE "OMAC.DEF"           'Include-Datei mit Definitionen vom April 2010
          INCLUDE "omax0.def"            ' Definitionen fuer die Open-MAXI
          ' für andere Versionen abändern
'*********************************************************************************************

' --- Definitionen Variable fuer das Hauptprogramm
'    Variabendefinition primitiv geschrieben (auf MAXI, MACRO natürlich WORD o. LONG-Variablen möglich
'
  '    ASMB1a bis d             => 32 Bit Zahl aus der Wurzel gezogen und das Ergebnis
  DEFINE ASMB1a  BYTE[1]       ' dargestellt wird
  DEFINE ASMB1b  BYTE[2]
  DEFINE ASMB1c  BYTE[3]
  DEFINE ASMB1d  BYTE[4]
  '      ASMB2a bis d           => 32 Bit Zahl  wird als Zwischenspeicher benötigt, nach Rechnungsende
  DEFINE ASMB2a  BYTE[5]       ' wird ASMB2 auf Null gesetzt
  DEFINE ASMB2b  BYTE[6]
  DEFINE ASMB2c  BYTE[7]
  DEFINE ASMB2d  BYTE[8]

  '      ASMB3a bis d           => 32 Bit Zahl Im DemoProgramm als Zähler
  DEFINE ASMB3a  BYTE[9]
  DEFINE ASMB3b  BYTE[10]
  DEFINE ASMB3c  BYTE[11]
  DEFINE ASMB3d  BYTE[12]
  DEFINE i       BYTE[13]     ' DemoProgramm als Diskriminator
  DEFINE Error   BYTE[14]     ' Zur Fehlerkennzeichnung
  DEFINE Resultb BYTE[15]
  DEFINE Resultc BYTE[16]
  DEFINE Resultd BYTE[17]

' Hauptprogramm-----------------------------------------------

    #Main
     Input i                                         ' HexWert-Ausgabe    310
     PRINT:PRINT "(1)-SQRT_32BIT_Round"
     PRINT "(2)-SQRT_32BIT_NachKomma"
     PRINT "(3)-Fehlersuche_Round"
     PRINT "(4)-Fehlersuche_Komma"

     INPUT i
   PRINT "StartWerte (Dezimal)"
     PRINT "? a: ";:INPUT ASMB3a:PRINT ASMB3a
     PRINT "? b: ";:INPUT ASMB3b:PRINT ASMB3b
     PRINT "? c: ";:INPUT ASMB3c:PRINT ASMB3c
     PRINT "? d: ";:INPUT ASMB3d:PRINT ASMB3d

     IF i>2 THEN GOTO Fehlersuche
     GOTO Einsprung                               'Springt mit Startwerten in For-next Routine

     IF i=2 THEN PRINT "Kein Fehler:&Habcd c-neu(.),b-neu(Wert), a-neu(Wert/Ergebnis) ":
     #Start
        For ASMB3a=0 to 255
          For ASMB3b=0 to 255
            For ASMB3c=0 to 255
              For ASMB3d=0 to 255
              #Einsprung
                GOSUB WertUebergabe
                 IF I=1 THEN GOSUB SQRT_32BIT_Round:GOSUB Ausgab3:GOSUB Ausgab1:GOSUB Ausgab2:GOTO Weiter
                  GOSUB SQRT_32BIT_NachKomma: GOSUB Ausgab3:GOSUB Ausgab1:GOSUB Ausgab2
                  PRINT ",";:IF ASMB2d<10 THEN PRINT "0";
                  PRINT ASMB2d;
                  #Weiter
                  PRINT
         NEXT:NEXT:NEXT:NEXT
         GOTO MAIN
'************************************************************************************
'      Fehlersuche - BASIC - Aufrufprogramm
'************************************************************************************
     #Fehlersuche
     PRINT "Fehlersuche -> ";
     IF i=3 THEN PRINT "Rundungsprogramm" ELSE PRINT "Nachkommastellen"
     ?"Zeige bei Wurzel aus $xxXXxxxx Änderung von XX an"
     #SuchWeiter
     GOSUB SQRT_32BIT_Control :PRINT
    ' IF ERROR = 255 THEN ERROR=0:GOTO SuchWeiter
     IF ERROR =254  THEN GOTO Ende
     IF ERROR >0 THEN GOSUB Ausgab0:
     GOSUB Ausgab3:GOsub Ausgab1:GOSUB Ausgab2:
     IF i=3 THEN  GOTO SuchWeiter
       PRINT " , ";:IF ASMB2d<10 THEN PRINT "0";
       PRINT ASMB2d; :PRINT
     GOTO SuchWeiter


#Ausgab0: PRINT "Error: ";ERROR;"  *************** E R R O R *****************":RETURN
#Ausgab1: PRINT " =>";:  Return
#Ausgab2: Print ASMB1a,ASMB1b,ASMB1c,ASMB1d;:Return
#Ausgab3: Print ASMB3a,ASMB3b,ASMB3c,ASMB3d;:Return
#WertUebergabe:  ASMB1a=ASMB3a:ASMB1b=ASMB3b:ASMB1c=ASMB3c:ASMB1d=ASMB3d: Return

'**************************************************************************************************
'      SQRT_32BIT_Round  Zieht die Wurzel aus einer 4Byte - Zahl
'      nutzt 8 Byte-Speicher. Speicher der jeweiligen 4Byte-Zahl müssen zusammenhängend sein
'      Wurzeln aus Nicht-Quadratzahlen werden gerundet:
'       Aus Wurzel von 8 ist das Ergebnis 3; aus Wurzel 7 => 3; aus Wurzel 6 => 2; aus Wurzel 5 => 2
'**************************************************************************************************
 PROCEDURE SQRT_32BIT_Round INLASM       'Berechnet die Wurzel und rundet das Ergebnis:  1338
          #SQRT_32BIT_Round_ASM
          !LDA #17                           ' Zähler: 17= 16 BytePaare + 1 Nachkomma
          !PSHA:!CLRA:!PSHA:!PSHA:!PSHA      ' Speicher schaffen für Result
      #Loop_SQRT_Rnd                          ' rechnet zu Fuss mit binomischer Formel
          !JSR Schieb_SQRT_Rnd                ' Zwei Bits herunterholen und nach ASMB2 schieben
      #Start_SQRT_Rnd
          !ASL 3,SP:!ROL 2,SP:!ROL 1,SP       ' ErgebZiff mit 2 multiplizieren
          !SEC:!ROL 3,SP:!ROL 2,SP:!ROL 1,SP  '   und mit 1 erweitern
          !CLRA:!PSHA:!PULH:!LDX 1,SP         '    für LDHX(0;1,SP)
          !CPHX ASMB2a                        '
          !BHI NoSubtrak_SQRT_Rnd             ' wenn HX>als Jump-C=0,Z=0
          !LDA 2,SP:!PSHA:!PULH:!LDX 3,SP     ' WennZiff+01> => nicht subtrahieren
          !CPHX ASMB2c
          !BHI NoSubtrak_SQRT_Rnd             '
      #Subtrak_SQRT_Rnd
          !LDA ASMB2d:!SUB 3,SP:!STA ASMB2d   ' Subtraktion -> Ergebnis nach ASMB2
          !LDA ASMB2c:!SBC 2,SP:!STA ASMB2c
          !LDA ASMB2b:!SBC 1,SP:!STA ASMB2b
          !LDA ASMB2a:!SBC #0:!STA ASMB2a
          !LDA #2:!ORA 3,SP:!STA 3,SP         ' 1 setzen
       #NoSubtrak_SQRT_Rnd
          !LSR 1,SP:!ROR 2,SP:!ROR 3,SP       ' Result regenerieren
       #Loop_END_SQRT_Rnd                     '
         !DBNZ 4,SP,Loop_SQRT_Rnd
          !PULA:!STA ASMB1b:!PULA             ' Ergebnis + 1 Nachkomma nach ASMB1
          !STA ASMB1c:!PULA:!STA ASMB1d
          !LSR ASMB1b:!ROR ASMB1c:!ROR ASMB1d ' NachKomma-Stelle in's Carry
          !LDA ASMB1d:!ADC #0:!STA ASMB1d     '  Aufrunden oder nicht
          !LDA ASMB1c:!ADC #0:!STA ASMB1c     ' größtes Ergebnis von &HFFFFFFFF=
          !LDA ASMB1b:!ADC #0:!STA ASMB1b     ' 65535,99=>FFFF oder gerundet=&H20000
          !LDHX #0:!STHX ASMB2a:!STHX ASMB2c   ' ASMB2 auf Null
          !PULA
          !RTS
  #Notgedrungen
       #Schieb_SQRT_Rnd                       ' Zahlenpaare von ASMB1 nach ASMB2
          !JSR Schieb1_SQRT_Rnd
       #Schieb1_SQRT_Rnd
          !ASL ASMB1d:!ROL ASMB1c:!ROL ASMB1b:!ROL ASMB1a
          !ROL ASMB2d:!ROL ASMB2c:!ROL ASMB2b:!ROL ASMB2a
          !RTS
       END PROCEDURE

'**************************************************************************************************
'      SQRT_32BIT_NachKomma  Zieht die Wurzel aus einer 4Byte - Zahl mit zwei Nachkommastellen
'      nutzt 8 Byte-Speicher. Speicher der jeweiligen 4Byte-Zahl müssen zusammenhängend sein
'       Die dezimale Nachkommastelle wird in ASMB2d abgelegt. Wenn in ASMB1 z.B. 12 steht und
'        ASMB2d = 4 ist, ist die berechnete Zahl = 12,04. Mit ASMB2d=99 ist das Ergebnis = 12,99
'**************************************************************************************************
'*********************************************************************************************
'    Tabelle enthält Zwei-Byte-Werte
'*********************************************************************************************
        TABLE NachKomma BYTE
      'DezimalWerte   5000 , 2500 ,  1250,   625  , 313  ,  156 ,  78  ,    39
      'HexWerte     13, 88,  9, C4, 4, E2,  2, 71, 1, 39 ,0 , 9C, 0, 4E,  0, 27  'Hexpaare
      '             19,136,  9,196, 4,226,  2,113, 1, 57 ,0 ,156, 0, 78,  0, 39  'Dezimalpaare
                    136,19,  196,9, 226,4,  113,2, 57,1,  156,0,   78,0,  39,0   'Umstellung aus Rechengründen
        TABEND
'*********************************************************************************************

PROCEDURE SQRT_32BIT_NachKomma INLASM           ' Berechnet Wurzel mit zwei Nachkommastelle
      #SQRT_32BIT_Komma_ASM                     ' ASM-Einsprung
           !LDA #24                             ' 24= 16 BytePaare + 8 Nachkomma =>Zähler
           !PSHA:!CLRA:!PSHA:!PSHA:!PSHA        ' Speicherraum schaffen
           !LDHX #0:!STHX ASMB2a:!STHX ASMB2c   ' ASMB2 = 0
     #Loop_SQRT_Rnd_Komma                       ' rechnet zu Fuss mit binomischer Formel
           !JSR Schieb_SQRT_Rnd_Komma
           !LDA 4,SP                            ' Zähler
           !CMP #8:!BHI Start_SQRT_Rnd_Komma    ' wenn<9 ASMbc,d restaurieren
           !LSR ASMB1c:!ROR ASMB1d:!LSR ASMB1c:!ROR ASMB1d
     #Start_SQRT_Rnd_Komma                      '  *2 +1
           !ASL 3,SP:!ROL 2,SP:!ROL 1,SP        ' ErgebZiff mit 2 multiplizieren
           !TPA                                 ' Carry retten
           !LDX 4,SP:!CPX #8:
           !BHI NoASMB1d_used_Komma             ' wenn Zähler <9 dann ASMB1d nutzen
           !TAP                                 '  Carry restaurieren
           !ROL ASMB1d
     #NoASMB1d_used_Komma
           !LDHX #0                             'HX=0
           !SEC:!ROL 3,SP:!ROL 2,SP:!ROL 1,SP   ' und mit 1 erweitern
           !TPA:!LDX 4,SP:!CPX #8
           !BHI NoASMB1d_used2_Komma:!TAP       'Carry restaurieren
           !ROL ASMB1d
     'Ab jetzt Vergleich:
           !LDA ASMB1d:!PSHA:!PULH
     #NoASMB1d_used2_Komma                      ' jetzt Vergleich
           !LDX 1,SP                            ' LDHX(2,SP)
           !CPHX ASMB2a                         ' WennZiff+01> => nicht subtrahieren
           !BHI NoSubtrak_SQRT_Rnd_Komma        ' wenn HX>als Jump-C=0,Z=0
           !BEQ Test_nochmal_Komma
           !BRA Subtrak_SQRT_Rnd_Komma
     #Test_nochmal_Komma
           !LDA 2,SP:!PSHA:!PULH:!LDX 3,SP
           !CPHX ASMB2c                          ' WennZiff+01> => nicht subtrahieren
           !BHI NoSubtrak_SQRT_Rnd_Komma
     #Subtrak_SQRT_Rnd_Komma
           !LDA ASMB2d:!SUB 3,SP:!STA ASMB2d     ' Subtraktion Sub1-Res1 - Ergebnis nach ASMB2
           !LDA ASMB2c:!SBC 2,SP:!STA ASMB2c
           !LDA ASMB2b:!SBC 1,SP:!STA ASMB2b
           !TPA:!LDX 4,SP:!CPX #8
           !BHI NoASMB1_used3_Komma:!TAP
           !LDA ASMB2a:!SBC ASMB1d:!STA ASMB2a
      #NoASMB1_used3_Komma
           !LDA #2:!ORA 3,SP:!STA 3,SP           ' 1 setzen
      #NoSubtrak_SQRT_Rnd_Komma
           !LDX 4,SP:!CPX #8:!BHI NoASMB1_used4_Komma
           !LSR ASMB1d:!ROR 1,SP
           !BRA NoASMB1_used5_Komma
      #NoASMB1_used4_Komma
           !LSR 1,SP
      #NoASMB1_used5_Komma
           !ROR 2,SP:!ROR 3,SP:!LDX 4,SP         ' Result regenerieren
      #Loop_END_SQRT_Rnd_Komma                   ' in ASMB2 ist die Differenz zur nächsten Quadrat-Zahl
           !DBNZ 4,SP,Sprung_Komma               '  Vorkomma-Ergebnis in SP,1&SP,2
           !PULA:!STA ASMB1c:!PULA               '  Ergebnis + 1 Nachkomma nach ASMB1
           !STA ASMB1d:!PULA:!STA ASMB2a         '  Ergebnis nun in ASMB1c,d;8Bit-Nachkomma in ASMB2a
           !LDA #8                               ' Zähler
           !STA 1,SP:!LDHX #0
           !STHX ASMB2c                          ' Speicher frei machen
           !LDHX #NachKomma                      ' TabellenAdresse
      #Loop_Nachkomma_Komma
           !ROL ASMB2a                           ' Komma-Wert in's Carry
           !BCC NoAdd_Komma:!CLC                 ' Clear Carry
           !LDA ASMB2d:!ADD ,X:!STA ASMB2d
           !LDA ASMB2c:!AIX #1:!ADC ,X
           !STA ASMB2c:!AIX #-1
      #NoAdd_Komma
           !AIX #2:!DBNZ 1,SP,Loop_Nachkomma_Komma
           !LDA ASMB2c:!PSHA:!PULH:!LDA ASMB2d
           !LDX #100:!DIV:!LDHX #0:!STHX ASMB1a  ' Lösche Speicher
           !STHX ASMB2a:!STHX ASMB2b:!STA ASMB2d ' Nachkomma nun in ASMB2d
           !PULA                                 '  Stack ok
           !RTS
       #Sprung_Komma
           !JMP Loop_SQRT_Rnd_Komma
        #Schieb_SQRT_Rnd_Komma                   ' Zahlenpaare von ASMB1 nach ASMB2
           !JSR Schieb_SQRT1_Komma
        #Schieb_SQRT1_Komma                      'links-schieb
           !ASL ASMB1d:!ROL ASMB1c:!ROL ASMB1b
           !ROL ASMB1a:!ROL ASMB2d:!ROL ASMB2c
           !ROL ASMB2b:!ROL ASMB2a
           !RTS
        END PROCEDURE




'*********************************************************************************************
'         Include-Dateien   (* Nicht notwendig für den Betrieb)
'*********************************************************************************************
'   Include "ASHilf1.Pro"             ' Assembler-HilfsDatei - Ausgaben direkt aus ASM
    Include "OM_FW.Pro"               ' Assembler-HilfsDatei - OM-SprungAdressen
'   Include "Calc32Bit.Pro"           ' Assembler-Hilfsroutinten - 32Bit-Rechnen
'   Include "SD_HILF_Hardware.PRO"    '* Assembler-HilfsDatei - ON/OFF-Ports (SS,CLK,MISO,MOSI)
'   Include "CRC7_CRC16.PRO"         '* Assembler-HilfsDatei - Berechnung von CRC7/CRC16


'--------------------------------------------------------------------------------------
'      Kontrollprogramm  - nur benötigt um die Stetigkeit und damit
'            Richtigkeit der Rechnung zu kontrollieren
'         Unterscheidung zwischen den Rechnungen mit der VergabeNummer von i
'           i=1 -> Rundungsprogramm; i=2 -> Nachkommaprogramm
'--------------------------------------------------------------------------------------
     PROCEDURE SQRT_32BIT_Control INLASM
'*************************************************************************************
          #WertStart
         ' !LDA #0:!CBEQ ERROR,NoERROR:!RTS
          #NoERROR
          !MOV ASMB3a,ASMB1a           ' Wertübergabe
          !MOV ASMB3b,ASMB1b
          !MOV ASMB3c,ASMB1c
          !MOV ASMB3d,ASMB1d
          !BRSET 0,i,SQRT_32BIT_Round_ASM_1                             'i=1
          !BRA SQRT_32BIT_Komma_ASM2
          #Test_Weiter
          !INC ASMB3d:!LDA ASMB3d:!CBEQA #0,Add_ASMB3c:!BRA WertStart
          #Add_ASMB3c
           !LDA #".":!JSR FwPutSci                            'ZeichenAusgabe
           !INC ASMB3c:!LDA ASMB3c:!CBEQA #0,Add_ASMB3b:!BRA WertStart
          #Add_ASMB3b
           !INC ASMB3b:!LDA ASMB3b:!CBEQA #0,Add_ASMB3a:!RTS  'WertAusgabe
          #Add_ASMB3a
           !INC ASMB3a:!LDA ASMB3a:!CBEQA #0,Control_End:!RTS
          #Control_End:!MOV #254, ERROR     'Haben fertig
          !RTS

'*********************************************************************
          #SQRT_32BIT_Round_ASM_1:!JSR SQRT_32BIT_Round_ASM
'**********************************************************************
          !LDA ASMB1d                  'aktuelles Ergebnis
          !SUB Resultd                 'vorheriges Ergebnis
          !TAX                         'Ergebnis merken
          !LDA ASMB1c
          !SBC Resultc
          !BCS Fehler                  ' wenn Ergebnis negativ würde
          !PSHA:!PULH                  ' Diff in HX
          !CPHX #1
          !BHI Fehler                  'Wenn Differenz>1, dann Fehler
          !BEQ DiffOk                  'Differenz = 1 -> ok
          !BRA DiffOk
     #Fehler
          !INC ERROR                   ' ERROR=ERROR+1
          !BrA Test_Weiter
     #DiffOk
          !LDHX ASMB1c:!STHX Resultc  'Schiebe Ergebnis nach vorheriges Ergebnis
          !CLR ERROR
          !BRA Test_Weiter
'***************************************************************************************
          #SQRT_32BIT_Komma_ASM2:!JSR SQRT_32BIT_Komma_ASM
'         Prüft, ob aufeinander folgende Ergebnisse >= sind
'***************************************************************************************
          !LDHX Resultc:!CPHX ASMB1c                'neue Zahl muß>=alt sein
          !BHI Nachk_Error                          'wenn Alte> ist, dann Fehler
          !BEQ NachkKontrolle                       'wenn =, dann Kontrolle
        #NachK_OK
          !LDHX ASMB1c:!STHX Resultc                'Result merken
          !LDA ASMB2d:!STA Resultb
          !JMP Test_Weiter
        #Nachk_Error
          !INC ERROR:!RTS
        #NachkKontrolle
          !LDA Resultb:!CMP ASMB2d                  'wenn altNachkomma>,dann Fehler
          !BHI Nachk_Error
          !BRA NachK_OK
          END PROCEDURE
 #Ende
END





> Hallo GeKue,
>
> danke vielmals für Deine Bemühungen; ohne Deine Hilfe wäre ich in meinem Projekt "Antennen tracking"  nicht voran gekommen. Meine Assemblerkenntnisse sind leider nicht ausreichend für so komplexe Programme wie z.B. die Wurzelaufgabe.
>
> sobald das Finale Programm verfügbar ist, werde ich es einbauen in mein Programm. Es eilt mir nicht, da ich derzeit noch mit anderen Programmteilen beschäftigt bin.
> Danke nochmals
>
> Viele Grüße   Joe

 Antwort schreiben

Bisherige Antworten:

Re: Quadratwurzel von 32 Bit Zahl (von Joe - 31.01.2015 15:35)
    Re: Quadratwurzel von 32 Bit Zahl (von Joe - 2.04.2015 16:35)