ALGORITHMEN UND ANDERES ZEUG - Teil XIII

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

Unsere Datenschutzerklärung wurde aktualisiert. Mit der Nutzung unseres Forums akzeptierst Du unsere Datenschutzerklärung. Du bestätigst zudem, dass Du mindestens 16 Jahre alt bist.

  • Abt. Ungeordnete Partitionen natürlicher Zahlen
    ==============================
    Die Zahl 4 kann auf p(4)=5 verschiedene Arten zusammengesetzt werden:
    (1) 4, (2) 3+1, (3) 2+2, (4) 2+1+1, (5) 1+1+1++1. Das war ja leicht. Aber wie ist das bei der Zahl 114 ? Oder bei 1024 ?

    Die Anzahl der unterschiedlichen Zusammensetzungsarten bei ungeordneter Anordnung der Teilsummanden und mit erlaubter Wiederholung nennt sich Partitionszahl. Sie spielt gleich in mehreren Gebieten der Mathematik eine Rolle, etwa bei topologischen Fragen, Gruppentheorie, auch in der Graphentheorie. Manche Beweise müssen z.B. alle Partitionen eines Problems einzeln behandeln, um als gültig angesehen zu werden.

    Naja, so weit wollen wir´s ja nicht treiben. Anbei ein Progi, daß einige genaue Werte sowie eine bekannte Abschätzungsformel für größere Zahlen enthält.
    Gruss

    Quellcode

    1. Windowtitle "Anzahl der ungeordneten Partitionen einer natürlichen Zahl"
    2. Windowstyle 24:Window 0,0-%maxx,%maxy:showmax:cls rgb(190,190,190):font 2
    3. declare z!,p!,antw$,p$,part$[],part![],max&,n&,sum!,k&,i1&,i2&
    4. p$="1,1,2,3,5,7,11,15,22,30,42,56,77,101,135,176,231,297,385,490,627,\
    5. 792,1002,1255,1575,1958,2436,3010,3718,4565,5604,6842,8349,10143,\
    6. 12310,14883,17977,21637,26015,31185,37338,44583,53174,63261,75175,\
    7. 89134,105558,124754,147273,173525,204226,239943,281589,329931,386155,\
    8. 451276,526823,614154,715220,831820,966467,1121505,1300156,1505499,\
    9. 1741630,2012558,2323520,2679689,3087735,3554345,4087968,4697205,\
    10. 5392783,6185689,7089500,8118264,9289091,10619863,12132164,13848650,\
    11. 15796476,18004327,20506255,23338469,26543660,30167357,34262962,\
    12. 38887673,44108109,49995925,56634173,64112359,72533807,82010177,\
    13. 92669720,104651419,118114304,133230930,150198136,169229875,190569292,\
    14. 214481126,241265379,271248950,304801365,342325709,384276336,431149389,\
    15. 483502844,541946240,607163746,679903203,761002156,851376628,952050665"
    16. part$[]=explode(p$,","):part![]=val(part$[&index]):max&=sizeof(part![]):clear part$[]
    17. Nochmal:
    18. Print "\n Zahl = ";:input z!:print
    19. if z!<0:p!=0:print " Von negativen Zahlen gibt es keine Partitionen!":goto "nochmal"
    20. endif
    21. if (z!>=0) and (z!<115)
    22. p!=val(substr$(p$,int(z!+1),",")):goto "showit"
    23. else
    24. SELECT z!
    25. 'caseof 2:p!=2
    26. 'caseof 4:p!=5
    27. 'caseof 8:p!=22
    28. 'caseof 16:p!=231
    29. 'caseof 32:p!=8349
    30. 'caseof 64:p!=1741630
    31. 'caseof 100:p!=190569292
    32. caseof 128:p!=4351078600
    33. caseof 200:p!=3972999029388
    34. caseof 256:p!=365749566870782
    35. caseof 512:p!=4453575699570940947378
    36. caseof 1024:p!=61847822068260244309086870983975
    37. 'caseof 2048:p!="18116048323611252751541173......020513022685"
    38. OTHERWISE
    39. p!=round( (exp(1)^(Pi()*sqrt(z!*2/3))) / (4*z!*sqrt(3)) ,0)
    40. Print " Gemäß Näherung von Hardy & Ramanujan [1918]: \n"
    41. print " Von ";format$("%g",z!);" gibt es ungefähr ";format$("%g",p!);
    42. print " ungeordnete Partitionen."
    43. goto "nochmal"
    44. ENDSELECT
    45. endif
    46. showit:
    47. print " Von ";format$("%g",z!);" gibt es ";format$("%g",p!);" ungeordnete Partitionen."
    48. Goto "Nochmal"
    Alles anzeigen

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von p. specht ()

  • Abt. Partitionszahl, die Zweite
    ===================
    Das gleiche wie oben, aber dafür nach der klassischen Pentagonalzahlenformel von Leonard Euler (um ca. 1740 herum). Verfahrensbedingt langsam, umständlich und über Inputwerten von 295 nicht mehr auf alle Stellen genau: Oftmaliges Subrahieren von riesigen Werten hat halt seine Tücken...
    Gruss

    P.S.: Zur Überprüfung eigent sich Wolfram-Alpha online, Stichwort "Partitions of "+ Wert

    Quellcode

    1. WindowTitle "Partitionszahl x ==> P(x) per Staffelrechnung nach EULER ermittlen"
    2. '(CL) CopyLeft 2017-04 by P.Specht, Vienna/Austria; Ohne jedwede Gewähr!
    3. WindowStyle 24:Cls:Font 2
    4. Proc P :parameters n& 'zwischen 2 und 1540 gültig (Rekursion gerät sonst aus den Fugen)
    5. Declare sum!,ct&,cth&,vz&,i1&,i2&,m1&,m2&
    6. WhileLoop n&
    7. CaseNot &Loop mod 3:Continue 'Nichtpentagonalzahl-Differenzen abweisen
    8. Inc ct&
    9. cth&=(ct&+1)/2
    10. vz&=if(cth& mod 2,1,-1)
    11. If ct& mod 2
    12. i1&=i1&+&Loop
    13. else
    14. i2&=i2&+&Loop ' i1,i2 ... Pentagonalzahlen
    15. m1&=n&-i1&
    16. m2&=n&-i2& ' m1,m2 ... Indizes der 2 rekurrierten Werte
    17. case (m1&<0) and (m2&<0):break ' nicht bis -INF wie in der Formel ;-)
    18. sum!=sum!+vz&*(if(m1&<0,0,A![m1&])+if(m2&<0,0,A![m2&]))
    19. EndIf
    20. EndWhile
    21. Return sum!
    22. EndProc
    23. PROGRAMM:
    24. Var max&=1524 ' Gefragt ist eigentlich nur dieser Wert, aber zur Ermittlung
    25. ' sind bei kleinen Zahlen relativ viele niedrigere Tabellenwerte nötig.
    26. ' (Der Rekursionsoverhead wäre groß, daher wird gleich die ganze Tabelle erstellt.)
    27. ' Theorem von Euler [18.Jhdt]: Sei p(0)=1 (und für alle n<0 p(n)=0).
    28. ' Dann gilt für alle n>=1: p(n)= p(n-1)+p(n-2)-p(n-5)-p(n-7)+p(n-11)+p(n-15)-...
    29. ' Anm.: Hier treten die sog. Pentagonalzahlen auf (sh. https://oeis.org/A001318 )
    30. if (max&<2) or (max&>1540):beep:print "\n Ausserhalb Gültigkeitsbereich, sorry!":waitinput:end:endif
    31. Declare A![max&],Wert!,Probe!
    32. A![0]=1:A![1]=1
    33. WhileLoop 2,Max&
    34. A![&Loop]=P(&Loop)
    35. Wert!=A![&Loop]
    36. ' casenot rnd(150):print "."; 'Lebenszeichen
    37. print " x = ";&Loop,tab(12);" p(x)= ";format$("%g",Wert!)
    38. EndWhile
    39. beep
    40. case (max&>296) and (max&<=500):print "\n Ausgabewert nicht mehr stückgenau!"
    41. case (max&>500) and (max&<=1500):print "\n Nurmehr auf 8 Stellen genau!"
    42. case max&>1500:print "\n Nurmehr Größenordnung gültig!"
    43. Print "\n ERGEBNIS: x = ";max&,Tab(22);" p(x)= ";Format$("##############,##0",A![Max&])
    44. clearclip:putclip Format$("################0",A![Max&])
    45. print:font 0
    46. case max&>1500:print " Überprüfung mit Wolfram Alpha-Online empfohlen, z.B. so:"
    47. case max&>1500:print " http://www.wolframalpha.com/input/?source=nav&i=partitions+of+297"
    48. waitinput
    49. end
    Alles anzeigen

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von p. specht ()

  • Abt. Zwischenstand: XProfan-X4ß und FPU-Befehle
    ================================
    Chefprogrammierer RGH hat einige Gleitkommabefehle in den XProfan-Inline-Assembler aufgenommen. Wegen API-Konventionen von Windows-32 ist die direkte Übergabe von Floatingpoint-Werten im Moment auf Single Precision (4 Byte) beschränkt (XProfan selbst rechnet standardmäßig mit Double Precision = 8 Byte). Deshalb sind derzeit nur Befehle implementiert, die sich auf 4-Byte-Floatingpointarithmetik im Bereich von 1.18×10^–38 bis ca. 3.40×10^38 beziehen. Bei diesem Format werden die 32 bit aufgeteilt in Vorzeichen+24 bit Mantisse und Vorzeichen+6 bit Exponent. Für Spieleanwendungen reicht das vollkommen, auf dem Mars würde ich damit wohl nicht landen.
    Gruss

    P.S.: Habe mir dazu ein erstes Merkblatt XASM FPU-Befehle gebastelt - wie immer ohne Gewähr!
  • Abt. Bedingte Ausführung mit RGH-XASM oder anderen Mitteln
    =======================================
    (Der Vollständigkeit halber auch in diesem Thread, damit mein Backup das erfasst)

    Quellcode

    1. Windowstyle 24:Window 800,600
    2. var errorlevel&=set("Errorlevel",-1):get("ASMMODE")
    3. var error%=%error:errorlevel&=set("Errorlevel",errorlevel&)
    4. if error%=0
    5. var hDLL&=UseDLL("USER32.DLL"):ImportFunc(hDLL&,"MessageBoxA",""):set("ASMMODE",0)
    6. ASM "MsgBox",1:JMP Start:Typ::DD 51:Titel::DS "Wichtige Meldung!\z":Text:
    7. DS "Das ist der Hinweis!\z":Start::MOV EAX,[Typ]:PUSH EAX:MOV EAX,Titel
    8. PUSH EAX:MOV EAX,Text:PUSH EAX:MOV EAX,Par1:PUSH EAX:CALL @MessageBoxA:ENDASM
    9. Print MsgBox(%hWnd)
    10. else
    11. Print " Funktion ASM steht nicht zur Verfügung! Ergebnis herkömmlich zu programmieren oder mit externen Assemblern"
    12. endif
    13. waitinput 1e5
    14. end
    Alles anzeigen
    P.S.: Nicht vergessen: @ hat in XASM die CALL-Adress-Bereitstellungsfunktion, damit isr FCALL überflüssig. Und mittels ProcAddr(NameDerProcOhneAnführungszeichen, 1) kann man auch XProfan-Prozeduren aus Assembler heraus aufrufen, wenn man das dem ASM-Call via Parameter Par1 (oder bis Par15) mitteilt. Im Merkblatt_XASM.pdf steht das dzt. noch nicht...

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von p. specht ()

  • Abt. Doppelt gemoppelt
    ===============
    Manche Rechnungen sollten schnell UND genau sein. XProfan bietet DoublePrecision 64bit-Floats, während die FPU selbst sogar mit 80 bit rechnet. RGH-XASM bietet Geschwindigkeit und Maschinenzugriff - Herz, was wllst du mehr? Anbei ein erster Gehversuch...

    Gruss

    Quellcode

    1. WindowTitle "Eine Variante der DoublePrecision-Übergabe"
    2. ' (D) Demo 2017-04 für XProfan 14.0ß by P. Specht, Wien
    3. ' Ohne jede Gewähr! Nutzung auf Risiko der/des Anwender/in/s
    4. cls
    5. Set("AsmMode",0)
    6. set("decimals",17) // !
    7. ASM "TST",0
    8. jmp Start
    9. Erg:
    10. DH "00000000000000000000"
    11. Start:
    12. mov eax,Erg // Code-Modifikation (!):
    13. mov [adr],eax // Adresse für FPU-Befehl setzen
    14. FLDPI // Ergebnisbeispiel: Lade Konstante Pi (80 bit)
    15. DH "DD1D":adr::dd 0 //= FSTP m64fp >>>[adr]
    16. mov eax,Erg // Ergebnisadresse(n) der Nachwelt mitteilen
    17. ENDASM
    18. print:print float(Tst(),0),\
    19. " Probe: Abweichung gegen XPprofan:",float(Tst(),0)-pi()
    20. waitinput 20000
    21. end
    Alles anzeigen
  • Abt. Rein - Raus
    ==========
    Wie gesagt, mir ist es mit einigen Kunstgriffen nun gelungen, auch eine DoublePrecision Wert in den XASM reinzubekommen. Ich bin sicher, wenn man die richtigen Op-Sequenzen wüsste, ginge das noch wesentlich eleganter. Bei mir kamen bei anderen Varianten abe nur ständig "Privilege Errors", deshalb bin ich froh, daß wenigstens irgendwas klappt.

    Naja, mühsam ernährt sich das Eichhörnchen...

    Gruss

    Quellcode

    1. WindowTitle "Eingabe einer DoublePrecision-Variable in ASM"
    2. cls:Set("AsmMode",0):set("decimals",17)
    3. ASM "TST2",1
    4. jmp Start
    5. Wert:
    6. Lo::Dd 0
    7. Hi::Dd 0
    8. Erg::DH "00000000000000000000"
    9. Start:
    10. mov eax,Erg
    11. mov [adr],eax
    12. mov eax,par1
    13. mov [wtadr],eax
    14. mov ebx,[eax]
    15. mov [lo],ebx
    16. add eax,4
    17. mov ebx,[eax]
    18. mov [Hi],ebx
    19. //FLD [Wert]
    20. DH "DD05"
    21. wtadr::dd 0
    22. //FLD1
    23. DH "DD1D" //FSTP m64fp >>>[adr]
    24. Adr::dd 0
    25. mov eax,Erg
    26. ENDASM
    27. declare P!
    28. P!=Pi()/2
    29. print:print " Ergebnis: ";float(Tst2(addr(P!)),0)
    30. print " Das sollte Pi/2 sein. Differenz: ";float(Tst2(addr(P!)),0)-Pi()/2
    31. waitinput 20000
    32. end
    Alles anzeigen
  • Abt. Ernüchterung
    ============
    Die Geschwindigkeitsbenchmarks der Programme in den beiden vorigen Beiträgen sind miserabel. Offenbar dauert die Vorbereitung auf die Übergabe eines 8-Byte-Floats (noch ausserhalb des Assemblerteils) viel zu lange!

    Durchgreifen direkt auf den Speicherplatz der Profanvariable will mir nicht gelingen (vermutlich wären da Kernel-Operationen nötig, die Windows verhindert). Da bekanntlich einige unserer Zeitgenossen viel Schaden anrichten wollen, ist das vielleicht sogar recht gut. X/

    Auch die Rückwandlung mittels float(eax&,0) dauert übrigens vergleichsweise lange. Man wird sich vermutlich doch zwischen schnell und genau entscheiden müssen... :roll:
    Gruss
  • Abt. FPU - ganz simpel (.chm)
    ==============
    würde der eingedeutschte Titel des englischen Standardwerks zum Thema FPU lauten. Eine italienische Site hat dazu eine .CHM-Hilfedatei gebastelt (Ob mit Einverständnis des Autors?). Das winzige Link mit der Bezeichnung "download" hätte ich fast übersehen...
    Gruss

    P.S.: Der Vergleich des FPU-Stacks (ST(0)-ST(7)) mit einem achtschüssigen Trommelrevolver hat tiefere Ähnichkeiten, als der Autor sich ursprünglich vielleicht gedacht hat... :-D
  • Zu den Geschwindigkeiten: Bei so einer simplen Funktion kann es da natürlich keinen Gewinn geben, weil das reine Rechnen hier im Vergleich zum Aufwand des Parsens durch den Interpreter verschwindend gering ist. Bei komplexeren Funktionen hingegen, die im XProfan-Code viele Zeilen beanspruchen würden, macht sich der Tempo-Boost dann aber deutlich bemerkbar!

    Zum Rest: Ich denke, ich werde noch DQ, FLD64, FST64 und FSTP64 einbauen, um das Übernehmen und übergeben von 64-Bit-genauen Werten zu vereinfachen. (Ja, die Syntax weicht dann von der offziellen etwas ab, macht es mir aber deutlich einfacher ... und dem Programmierer auch, wenn er nicht ständig DWORD PTR und QWORD PTR schreiben muss.

    Gruß
    Roland
    Intel Duo E8400 3,0 GHz / 4 GB RAM / 1000 GB HDD / ATI Radeon HD4770 512 MB / Windows 7(32) - XProfan X4
    AMD Athlon II X2 2,9 GHz / 3 GB RAM / 500 GB HDD / ATI Radeon 3000 (onboard) / Windows 10(64) - XProfan X4


    http://www.xprofan.de
  • Danke, das wäre eine große Hilfe.

    Ad "Merkblätter": Ich habe schon mehrere Updates hochgeladen, komme aber drauf, daß mein Firefox mir ständig die älteren Versionen zeigt. Schuld war, daß ich den Browser-Cache nicht geleert hatte. Bei einigen Browsern ist der default nicht auf "nach jeder Session Cache löschen" eingestellt, was ja sinnvoll sein kann, wenn man ständig auf bestimmtenn Seiten verkehrt. Hier aber ist es nicht gut:

    Abhilfe bei Firefox: Extras - Einstellungen - Erweitert - Netzwerk - [Jetzt leeren]

    An Merkblättern gibt es derzeit:

    Merkblatt_XASM.pdf
    XASM_FPU-Befehle.pdf
    Bedingungen&Schleifen.pdf
    X4-JSON.pdf

    und meine alte Zusammenstellung über DoublePrecision-Befehle: dpfp.pdf
    Weiters wegen der Flag-Info zu empfehlen ist der allgemeine Merkzettel von Roger Jegerlehner.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von p. specht ()

  • Ok, neue Version hochgeladen!

    Jetzt gibt es FLD64, FST64 und FSTP64 und als Zuckerl noch das DQ oben drauf. Dein ASM-Code reduziert sich somit auf vier Zeilen:


    Quellcode

    1. cls
    2. set("ASMMODE", 2)
    3. ASM "TST2",1
    4. jmp Start
    5. Erg::DQ 0
    6. Start:
    7. mov eax,par1 // In EAX ist nun die Adresse, an der der Doube-Parameer steht
    8. FLD64 [eax] // Die 64Bit, die dort stehen, landen auf dem FPU-Stack ...
    9. FSTP64 [Erg] // ... und werden unveränder an die Adresse Erg geschoben
    10. mov eax,Erg // Diese Adrese wird über EAX zurückgegeben
    11. ENDASM
    12. declare P!
    13. Set("DECIMALS", 11)
    14. P! = Pi()/2
    15. print:print "Ergebnis: ";float(Tst2(addr(P!)),0)
    16. print "Das sollte Pi/2 sein. Differenz: ";float(Tst2(addr(P!)),0) - Pi()/2
    17. waitinput
    18. end
    Alles anzeigen
    Gruß
    Roland
    Intel Duo E8400 3,0 GHz / 4 GB RAM / 1000 GB HDD / ATI Radeon HD4770 512 MB / Windows 7(32) - XProfan X4
    AMD Athlon II X2 2,9 GHz / 3 GB RAM / 500 GB HDD / ATI Radeon 3000 (onboard) / Windows 10(64) - XProfan X4


    http://www.xprofan.de
  • Frage hat sich erübrigt, das Beladen von XProfan-Variablen aus XASM heraus klappt jetzt.
    Dank an RGH!

    Quellcode

    1. cls:set("ASMMODE",0):Set("DECIMALS", 17)
    2. ASM "TST4",2:mov eax,par1:mov ebx,par2
    3. FLD64 [eax]:FLD1:FADD:FSTP64 [ebx]:mov eax,0 // Fehlercode
    4. ENDASM
    5. declare P!,Q!:P!=Pi()
    6. print "\n Übergabevariable P! derzeit ";P!
    7. print " Zielvariable Q! ist noch ";Q!
    8. print " Fehlermeldung (0=OK): ";Tst4(addr(P!),addr(Q!))
    9. print "\n ASM ausgeführt: Q! ist nun: ";q!
    10. print "\n Q! sollte Pi+1 sein. Differenz: ";Q! - (P!+1)
    11. print " Bei Differenz 0 hat das geklappt!"
    12. waitinput:end
    Alles anzeigen
  • Abt. Variable noch immer direkt beschickbar
    ============================
    Nachdem FLD64 und FST64 schon wieder veraltet sind, geht das nun mit FLD QWORD PTR [eax] bzw. FST QWORD PTR [ebx]:

    Quellcode

    1. CLS
    2. set("AsmMode",0)
    3. ASM "KREISFLAECHEa2e", 2
    4. MOV EAX,par1
    5. MOV EBX,par2
    6. FLD QWORD PTR [EAX]
    7. FLD ST
    8. FMUL
    9. FLDPI
    10. FMUL
    11. FSTP QWORD PTR [EBX]
    12. MOV EAX,0 //Erfolg
    13. ENDASM
    14. Programm:
    15. set("decimals",17)
    16. declare Ergeb!
    17. var R!=2.000000000000002
    18. Print " Fehlercode (0=Kein Fehler): ";KREISFLAECHEa2e(addr(R!),addr(Ergeb!))
    19. if Ergeb!=2.000000000000002^2*Pi():print "\n ERFOLG - Profanvariable direkt mit Ergebnis geladen!\n"
    20. print " R^2*Pi() mit R=2.000000000000002 :";Ergeb!
    21. else:print " ERROR! LEIDER KEIN ERFOLG! "
    22. endif:waitinput:end
    Alles anzeigen
    P.S.: Merkblatt upgedated :pfeifend:
  • Abt. Aviso Mondfinsternisse
    =================
    Partiell: 07.08.2017
    Sichtbarkeitsbeginn: ca. 18.35 Uhr MESZ
    Eintritt in Kernschatten: 19.23 Uhr MESZ
    Maximale Verfinsterung: 20.22 Uhr MESZ
    Austritt aus Kernschatten: 21.18 Uhr MESZ
    Sichtbarkeitsende (SE): ca. 22.10 Uhr MESZ

    Nächste Totale MF: 27.07.2018
    Gruss
  • Abt. Quaternions, Teil 2
    ===============
    Eine Rotation mittels Quarternions ergibt sich formal zu [0;w_rot]=z*[0;w]*z_konj ,
    wobei z=a+b*%i+c*%j+d*%k, |z|=1 und die Konjugierte z_konj=a−b*%i−c*%j−d*%k ist.

    In Computersprachen, die keine Quaternion-Class enthalten, muss man weiter auf herkömmliche
    Art arbeiten, nämlich per Orthogonalmatrix R, die einer Rotation mittels Quaternion z entspricht:

    R=(a^2+b^2−c^2−d^2, 2*b*c−2*a*d, 2*b*d+2*a*c;
    2*b*c+2*a*d, a^2−b^2+c^2−d^2, 2*c*d−2*a*b;
    2*b*d−2*a*c, 2*c*d+2*a*b, a^2−b^2−c^2+d^2)

    Ausgeführt wird diese Rotation duch Multiplikation mit dem nachgestellten Originalvektor w:

    [w_rot]´= R*[w]´

    Hinweis: Jedes beliebige Nicht-Einheits-Quaternion kann technisch per Division durch seine sog. "Quadranz" zu einem Einheitsquaternion gemacht werden. Die Quadrance eines Quaternions
    p = a+b*%i+c*%j+d*%k ergibt sich zu Q=a^2 - b^2 - c^2 - d^2. Die in dieser Art Geometrie vermiedene Wurzel daraus ergäbe die Euklidische Distanz, ebenfalls vermiedene Winkelangaben werden durch das sog. Keilmaß (engl. "Spread" - Spreizung) ersetzt.

    Eigentlich sind damit auch Rotationen im vollen 4D-Raum möglich, in der 3D-Rotationsdarstellung verzichtet man aber bewusst auf den Realteil.

    Gruss

    P.S.: Auch der sog. Dirac-Kabeltrick wird damit veranschaulicht. Er erklärt, warum es Teilchen mit Spin 1/2 geben kann: Das Teilchen braucht 2 ganze Umdrehungen, um in die Ausgangslage zurückzukkommen (Bildquelle: Wikipedia)
    [IMG:https://upload.wikimedia.org/wikipedia/commons/9/9e/Belt_Trick.gif]

    PPS.: So funktioniert auch eine bürstenlose Kabelverbindung in rotierenden Kleingeräten gem. US-Patent

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von p. specht ()

  • Abt. Rationale Trigonometrie
    ==================
    ... ist die moderne Variante einer Geometrie, die ohne Winkel, ohne sin, cos, tan und sogar ohne Wurzelziehen auskommen will, weil alle diese Funktionen letztlich nicht genau berechenbar sind, sondern nur mittels Taylorreihen, Newtonverfahren etc. angenähert werden können. Das klappt allerdings nur im "Quadratischen Raum", in dem Längen als Quadrat, sog. Quadranzen, ihrer euklidischen Längen angegeben werden, und statt Winkelgraden stets nur das Verhältnis von gegenüberliegender Quadranz zu Hypotenusenquadranz, die sog. Spreizung, angegeben wird.

    Es ergeben sich dann folgende Gesetzmäßigkeiten mit Längenquadranzen Q und Spreizungen s:

    1) Q1 + Q2 = Q3 (Pythagorias im rechtwingeligen Dreieck)
    2) (Q1+Q2-Q3)² = 4*Q1*Q2 (Quadrate über drei kolinearen Punkten)
    Im allgemeinen Dreieck:
    3) 16*Dreiecksfläche² = 4*Q1*Q2-(Q1+Q2-Q3)² = (Q1+Q2+Q3)²-2*(Q1²+Q2²+Q3²) // Archimedes
    4) s1 / Q1 = s2 / Q2 = s3 / Q3 (entspricht dem Sinussatz)
    5) (Q1+Q2-Q3)² = 4*Q1*Q2 *(1-s3) //Cross law, vgl.: Allgemeiner Pythagoras
    6) (s1+s2 - s3)²=4*s1*s2*(1-s3), oder anders ausgedrückt:
    6a) (s1+s2 + s3)²=2*(s1²+s2²+s3²)+4*s1*s2*s3 // Triple spread law
    7) Gegenüberliegende Teilungsspreizungen sind umgekehrt proportional zur Teilungsquadranz:
    r1/r2 = s1/s2 * R2/R1; Spreizung 0 = Parallele, Spreizung 1 = 90°/Rechter Winkel
    8) Spreizung zwischen 2 Vektoren: s = (x1*y2-x2*y1)²/( (x1²+y1²)*(x2²+y2²))
    9) Fibonacci´s Identität: (x1*y2+x2y1)²+(x1X2+y1y2)² = (x1²+y1²)*(x2²*y2²)
    10) Umrechnung: Länge = Sqrt(Quadranz) bzw. Quadranz = Länge²
    11) Umrechnung Spreizung s = sin²(Winkel) bzw. Winkel = ArcSin(Sqrt(Spreizung))
    12) Erweiterbarkeit auf komplexe Zahlen, Quaternions, Oktonnions etc. ist leicht möglich.

    Gruss

    P.S.: Details hier und hier.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von p. specht ()

  • Abt. Automatisierung und Künstliche Intelligenz
    ==============================
    Die Welt steht gerade im Umbruch: Industrie 4.0 steht vor der Tür und könnte bald jeden dritten Arbeitsplatz kosten, viele weitere bis zur Unkenntlichkeit "umkrempeln". Soziologen, Arbeitspsychologen und sog. "Change-Manager" haben zu solchen dramatischen Änderungen ein psychosoziales Phasenmodell erstellt, das ziemlich plausibel scheint:

    DIE 15 PHASEN EINES PARADIGMENWECHSELS
    0. Ausgangslage ("Normalität")
    * ERKENNTNIS DER ZU ENDE GEHENDEN ÄRA
    1. Leugnung von Änderungsnotwendigkeiten
    2. Befürchtungen, Verlustängste
    3. Schock, Verlust
    4. Existenzangst
    5. Frustration
    6. Verwirrung
    * NEUORIENTIERUNG:
    7. Stress
    8. Themenvermeidung
    9. Skepsis
    * WIEDERERSTARKUNG:
    10. Akzeptanz
    11. Ungeduld
    12. Hoffnung
    * NEUBEGINN:
    13. Energie
    14. Ethusiasmus
    15. Neue Normalität

    ... und das alles wiederholt sich im Laufe der Geschichte immer öfter.
    Gruss

    P.S.: Panta rei - alles fließt! Oder, wie die Wiener sagen: Nix is fix!

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von p. specht ()

  • Abt. Standardmodell der Hochenergie-Tellchenphysik
    =================================
    Wir alle und unsere gesamte Welt bestehen aus folgenden nicht weiter zerlegbaren Elementarteilchen:[IMG:http://members.aon.at/startup/StandardModel2017.gif]

    All diese Teilchen treten aber auch mit umgekehrten el. Ladungen auf ("Positron" statt Elektron etc.) Damit können dann die vier erforschten Urkräfte erklärt werden: Elektromagnetische Kraft, Gravitationskraft, Starke Kernkraft und die für Radioaktivität verantwortliche schwache Kernkraft. Unerforscht sind derzeit aber die "Dunkle" Materie, die mit unserer Welt kaum wechselwirkt ausser durch über-galaktische Gravitation, und die "Dunkle Energie", die den leeren Weltraum immer weiter auseinandertreibt.

    Es bleiben also noch genug Phänomene zu erforschen...
    Gruss

    P.S.: Normale Atomkerne werden aus Protonen (up-up-down, 1e+) und ev. Neutronen (up - down - down, e=0) gebildet (wobei diese in einem Meer von virtuellen Austauschteilchen schwimmen), und werden von Elektronen umkreist, wobei die chemischen Eigenschaften meist nur von den Elektronen der äussersten Schale(n) bestimmt werden.

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von p. specht ()