  INFO - FAQ - CC2-Forum - CCPro-Forum |
|
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 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 |
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)