Rework me on GitHub

z entlang einem Vektor

root (Edward Gerhold)

Die einfachste Projektion von x,y,z ist wohl die hier [x,y] + z*[cos(wz), sin(wz)] = [x+zcos(wz), y+zsin(wz)]. Ob wenigstens diese Form unterrichtet wird, kann ich auch nicht sagen. Wenn man jetzt das xy Koordinatensystem nimmt und einen Vektor für die z-Achse mit dem Winkel wz, dann kann man so den Punkt entlang der z-Achse verschieben. Meine Projektion macht alle drei Achsen beliebig drehbar und ich halte auch an dem Dokument fest, was dringend überarbeitet werden muss, weil ich soviele Sachen eintrug und weniger Zeit aufbrachte als ich brauchte. Heute abends geht´s ein paar Takte weiter, jetzt erstmal wieder raus. Aber [x,y]+z*[r*cos(wz),r*sin(wz)] sollte eine dritte Achse und ein korrektes Bild bringen.

Animation

root (Edward Gerhold)

Hier in diesem Demo kann man eine schöne trigonometrische Funktion bei der Drehung beobachten

[x,y,z]=f(t) plotter mit Cheap 3-D Technik

root (Edward Gerhold)

Vorhin habe ich ein neues File eingegeben, um mir mal die f(t) anzuzeigen. implement.html. Es ist gleichzeitig ein Demo für implement.js, einer Demo Implementierung des Transformationsalgorithmus, den ich fleißig und nachhaltig in gerhold-3dto2d.pdf zu einem richtigen Satz ausarbeite.

Wenn man im implement.html im ersten Input Field, durch Kommata getrennt, drei Array Elemente in JavaScript eingibt, um die Variable t zu verrechnen, dann gibt die Funktion f(t) auch [x,y,z] zurück. Ein Beispiel ist 32*Math.cos(t),15*Math.sin(t),t/2. Die Eingaben werden onchange mit transform2dAll(points3) konvertiert und mit draw2dAll(context, points2, scale) aus implement.js dann auf dem 2-D Canvas Context abgebildet. Das Intervall wird von start bis stop durchlaufen und zwar in times Schritten. Was man ausser dem Code für die drei Koordinaten ausserdem auch noch angeben kann. ausgabe_von_implement.html

Cheap 3-D: Full 3-D to 2-D ES6 function

root (Edward Gerhold)

Ausschnitt aus dem Dokument. Das ist die komplette Transformation der 3-D Punkte, ohne Umwege. Eine Demo hier. Die affinen Transformationen werden vorher und lokal auf den Punkten ausgeführt, wie bei normalen 3-D Programmen.

let rad = (deg) => Math.PI/180*deg;
let r_x = 1, r_y = 1, r_z = 1;
let phi_x = rad(220), phi_y = rad(330), phi_z = rad(90);
let xAxisCos = r_x*Math.cos(phi_x),
    yAxisCos = r_y*Math.cos(phi_y),
    zAxisCos = r_z*Math.cos(phi_z),
    xAxisSin = r_x*Math.sin(phi_x),
    yAxisSin = r_y*Math.sin(phi_y),
    zAxisSin = r_z*Math.sin(phi_z);
let transform2d = ([x,y,z]) => [
    x*xAxisCos+ y*yAxisCos+ z*zAxisCos,
    x*xAxisSin+ y*yAxisSin+ z*zAxisSin
];
let transform2dAll = (P) => P.map(transform2d);

let examplePoints = transform2dAll([[1,2,3], [3,4,5], [14,24,15]]);

Cheap 3-D logo und graph picture (draft)

root (Edward Gerhold)

cheap3dlogo Das Logo der Projektionsmatrix spiegelt das Prinzip wieder.

cheap3dgraph Das Bild zeigt das Koordinatensystem, die Winkel und die Einheitsvektoren, sowie cos-sin am Einheitsvektor. Ist nur viel zu klein und überarbeitungsbedürftig.

Arbeite bereits an dem offiziellen Paper dazu. Die aktuelle Version ist absolut noch nicht ausgereift.

Tagsüber lese ich gerade das Chemiebuch der Sekundarstufe I hier und lerne das, was ich damals nicht getan habe. In Mathematik und auch Physik bin ich bereits viel weiter und möchte mit aufschließen. Leider habe ich kein tragbares Gerät mehr, so daß ich unterwegs nichts elektronisch bearbeiten kann. Darum muss das über mehrere Tage entwickelt werden, anstatt über den Tag.

 

Cheap 3-D Rotation Animation

root (Edward Gerhold)

cheap3danimate Das ging sehr schnell. Ein Zähler wird zur Rotation addiert. Die komplette Funktion, wird jedesmal neu gerufen. "Das ermöglicht vorab Auslastungsstichproben", wollte ich noch hinzufügen. Und muss mich dabei korrigieren, weil ja der gesamte Handler per setTimeout wiederholt wird, und dabei das DOM ja ebenfalls jedesmal neu gelesen wird, wodurch das Ding zwar live auf Änderungen reagiert, aber fernab vom realistischen Auslastungstest ist, wo der Zugriff auf jeden Fall vorher rausgeflogen ist. Viel Vergnügen.

Update: Persönliche Meinung. Erst optimieren. Wenn man jetzt viel ändert, wird der Handler ständig zwischengerufen. Dabei geht mindestens der Lüfter irgendwann an.

Cheap 3D als TeX Dokument

root (Edward Gerhold)

cheap3drotate.html ist die letzte Datei von gestern. Heute habe ich mir dann überlegt, es auch richtig als TeX Datei aufzusetzen.

Der Korollar beweist die Erweiterbarkeit des Satzes auf mehr als drei Dimensionen, zum Beispiel Minkowski 4-D, und auch Hilberträume. Die Transformation zu niederen Dimensionen lässt sich mit rechteckigen Matrizen verallgemeinern.

Die besondere Änderung an der Matrix ist, daß ich anstelle von α, β, γ nun φx, φy, φz für die Winkel eingetragen habe. Das macht es noch einheitlicher.

α, β, γ erinnern viele direkt an die Winkel von Dreiecken. Letztendlich laufen wir hier die Wege der Ankatheten und Gegenkatheten auf dem Papier ab. Oder an charakteristische DGL vom Euler.

In der Mathematik variieren die Buchstaben in den Schriften und von Person zu Person, darum ist es eigentlich auch nicht wichtig, ob es jetzt φx oder α ist. Allerdings liest es sich so auch sehr gut.

A = [ rxcos(α), rycos(β), rzcos(γ); rxsin(α), rysin(β), rzsin(γ)]
= [ rxcos(φx), rycos(φy), rzcos(φz); rxsin(φx), rysin(φy), rzsin(φz)]
= [ ex, ey, ez ];

Seien A  ∈ ℜ2x3 ein linearer Operator, x ∈ ℜ3 der Eingabevektor und x' ∈ ℜ2 der Ausgabevektor, en ∈ ℜ2 hier ein zweidimensionaler Basisvektor für je eine xyz-Komponente von x für die Projektion auf die xy-Ebene (den ℜ2). Und rn sei die Längeneinheit des jeweiligen Basisvektors en.

Man wendet die Basis wie eine gleichgrosse Basis auf den Koordinatenvektor an.

Damit ist

x' = Σ enxn

oder

(x',y')T = A(x,y,z)T

oder in Worten

x`= Die Summe aus den Produkten von x,y,z mit ihren cos Termen
y' = Die Summe aus den Produkten von x,y,z mit ihren sin Termen
oder der neue Vektor die Summen aus den Produkten der Basis und dem alten Vektor.

Immernoch zu erledigen ist für mich, ein Bild von einem dreidimensionalen Koordinatensystem anzufertigen, auf dem drei Einheitsvektoren auf ihren Achsen in ihre Richtung schauen. Übrigens auch das Logo des Programms. Ein Einheitskreis mit drei Pfeilen drin. Auf dem Blatt Papier hat man das Lineal parallel zur Achse angelegt, und ist zu Fuß gegangen, oder halt mit den Koordinaten multipliziert. Letzteres machen wir nun praktisch mit der Rechenmaschine, und mit mehr Punkten als wir manuell berechnen würden.

Cheap 3-D Local Rotate

root (Edward Gerhold)

cheap3drotate.html Habe den trafo Code wieder vom DOM Code getrennt. Jetzt könnte man jedes x-beliebige Objekt unterschiedlich darstellen. Die Darstellung des aktuellen Graphen wirkt aber bereits verbessert, da die Achse nicht mehr mitrotiert und nicht übersetzt wird, nur weil ich die Daten nicht mit übergeben habe. Das ist aber noch nicht das Ende der Entwicklung. Natürlich geht das noch weiter...

Cheap 3-D als Gerhold Matrix

root (Edward Gerhold)

Erste Spezifikation der Gerhold Projektionsmatrix oder der Gerhold Transformation

Seien x,y,z Koordinaten im R3 und x', y' die resultierenden Koordinaten im R2.

Seien ex, ey, ez die Basisvektoren des Zielkoordinatensystems. Da die Abbildung
auf dem R2 stattfindet, sprich auf der xy-Ebene, sind diese drei Vektoren auch
zweidimensional. Jeder Vektor enthät eine x und eine y Komponente, um die
Richtung der abgebildeten Koordinatenachse zu beschreiben.

ex = (rx*cos(alpha), rz*sin(alpha))T, 
ey = (ry*cos(beta), ry*sin(beta))T, 
ez = (rz*cos(gamma), rz*sin(gamma))T

r{x,y,z} sind die Einheitslängen der Zielbasis je Richtung. Man kann
das resultierende Bild damit vergrößern und verkleinern, da damit die
Einheiten je Koordinatenachse festgelegt werden. Um korrekte Bilder zu erhalten, sollten
sie gleichgross bleiben und man lokale Koordinatensysteme zur Transformation wählen.

Seien α, β und γ die Winkel der drei Einheitsvektoren am Einheitskreis.
Um die Vektoren entsprechend den Winkeln auszurichten, werden die Winkel mit dem
jeweiligen Cosinus und Sinus für die x und die y Komponente angegeben.

Wenn man die Koordinaten transformiert, summiert man die Cosinusterme für x und
die Sinusterme für y. Um es zu erlaeutern, bewege ich mich nach links und 
nach rechts mit dem Kosinusterm, jeweils für x, für y und für z. Dadurch bleibe
ich an der korrekten Stelle stehen, oder mathematisch, erhalte ich die richtige
Zahl. Mit dem Sinusterm bewege ich mich für x, y und z jeweils nach oben oder 
nach unten. Diese gedachte Bewegung erreiche ich durch Multiplikation mit dem
Vektor. Das mache ich jeweils für die x und für die y Komponente getrennt mit
dem Kosinus und dem Sinusterm, dadurch erhalte ich die korrekten Koordinaten
auf der Ebene.

Da es sich um eine Summe mehrerer Produkte handelt, kann man es auch als Matrix
schreiben. Was sich der übersicht halber bewährt. Programmieren kann man es
aber auch direkt ohne Matrix. Die Projektionsmatrix ist 2x3 und rechteckig.

Wir benutzen nur zweidimensionale Basisvektoren, weil das Drei-Koordinaten-System
x,y,z im R2 in einem Zwei-Koordinaten-System eingebettet ist. Wir haben die Option
uns in verschiedene Richtungen zu bewegen.

P = [ ex0, ey0, ez0;
      ex1, ey1, ez1 ]

P ist eine 2x3 Projektionsmatrix. Die 0 steht für die x-Komponente, und die 1
für die y-Komponente unserer neuen Koordinatenbasis. Um das aufzuschlüßeln,
was ich sage, hier die volle Basis in lesbarer Form.

P = [ rx0*Math.cos(α), ry0*Math.cos(β), rz0*Math.cos(γ);
      rx1*Math.sin(α), ry1*Math.sin(β), rz1*Math.sin(γ) ];

Hier steht der r fur den Radius des (dann nicht mehr) Einheitskreises, im Falle, daß man nur
cos und sin wählt, ist er 1. Wenn man keine irritierenden Verzerrungen bei Rotationen von zu
projezierenden Objekten wünscht, sollte man die in alle drei Richtungen gleich gross machen und
ein lokales (mitrotierendes) 3x3 Koordinatensystem für seine Objekte und ihre eigene Transformation
wählen. Die 2x3 Projektionsmatrix ist für die Umwandlung von dreidimensionalen in zweidimensionale
Koordinaten wichtig.

Mit dem Demoprogramm kann ich beweisen, daß die Projektion dann
trotz Rotation dann wirklich korrekt bleibt. Während man den irritierenden Effekt unterschiedlicher
Basiseinheiten, ohne daß diese Einheiten lokal am Objekt mit einem eigenen Koordinatensystem festgemacht
werden, hier beobachten kann, wenn man das Objekt dreht. Lokale 
Koordinatensysteme sind in der Computergrafik und der Physik aber keine Besonderheit, darum sollte das kein
Problem darstellen.

Wenn man die Matrix anwendet, führt man eine Multiplikation mit dem xyz-Koordinatenvektor durch und
erhält einen x'y'-Koordinatenvektor.

P[x;y;z] = [x';y']

Das kann man in einer Schleife mit allen Punkten machen und eine neue Liste zurückgeben. Die Punkte
sind in der gleichen Reihenfolge, wie die 3-D Koordinaten vorher waren. Für den HTML5 Canvas zum
Beispiel kann man nun einfache lineTo´s durchführen und erhält die Linien, die die vorher 
dreidimensionale Fläche verbunden haben.

Für den Programmierer ist keine Matrix nötig. Es sind diese zwei läppischen Zeilen.

x' = x*r*cos(alpha) + y*r*cos(beta) + z*r*cos(gamma);
y' = x*r*sin(alpha) + y*r*sin(beta) + z*r*sin(gamma);

Um die Identifikation mit drei 2-D Basisvektoren, die aus je einem r*cos-Term für die x-Koordinate
und einem r*sin-Term für die y-Koordinate bestehen, einfach zu halten, habe ich die Matrix gerholdsch
genannt. Die Gerhold-Matrix ist 2x3 und hält drei 2-D Vektoren mit je r*cos Achswinkel für den neuen x und
r*sin Achswinkel für den neuen y Wert. 

G = [ rx0*Math.cos(α), ry0*Math.cos(β), rz0*Math.cos(γ); rx1*Math.sin(α), ry1*Math.sin(β), rz1*Math.sin(γ) ];
Die Summationsformel ist nahezu identisch mit der Summationsformel für die Multiplikation mit einer Orthogonalbasis, Σ enxn. Jedoch wird sie in der Literatur nur mit quadratischen Matrizen und gleichgrossen Basis- wie Objektvektoren behandelt.
In der Computergrafik wird eine 4x4 Version mit Viewport Division eingesetzt. Ich habe eigentlich jahrelang nach dieser Formel
gesucht und sie zuletzt selbst erfunden. Warum ich die Matrix zur Unterscheidung mit meinem Namen identifiziere. G*[x;y;z] = [x';y'].

Cheap 3-D Local units

root (Edward Gerhold)

cheap3dlocalunits.html Um die Rotation zu bewahren, aber vielleicht x und y 20 mal so gross zu machen, und z nur 4 mal so gross, muss das lokale Koordinatensystem her. Dieser Edit beschränkt sich auf die Einheiten, statt auf eine Vektorbasis, die eine weitere Verformung des Objekts ermöglicht. Möglicherweise der nächste Edit handhabt das so, dass man den Satz mit Ursprung, Translation, Rotationswinkeln, lokalen Einheiten je Objekt mit übergibt. Dieser hier bewahrt die größe bei der Rotation, obwohl sie veränderlich ist. Dazu habe ich die Projektionsvektoren wieder auf eine gleichgrosse Länge verkürzt.

Cheap 3-D Transform

root (Edward Gerhold)

cheap3dtransform Habe Ursprung, Translation und Rotation hinzugefügt.

Nachtrag: Wenn die Einheiten von x,y,z unterschiedlich eingestellt sind, dann wird der Körper beim drehen plötzlich in die Richtung der Vergrösserung gestreckt und in die andere wieder geschrumpft. Das ergibt einen unrealistischen Effekt. Weiterhin ist noch zu ergänzen: Perspektive. Mit einer dynamischen Länge der Einheiten hätte man z- und y- entlang der x-Achse perspektivisch hingekriegt. Der Fall Rotation/Einheiten der Basis spricht erstmal dagegen. Möglicherweise muss die Basis Einheitslang bleiben und ich diese Einheiten getrennt auf das Objekt in lokalen Objektkoordinaten anwenden. Womit wir eine zweite Basis kriegen, die mit rotiert, damit die Proportionen bei der Drehung bleiben und einfach mitgedreht werden.  Desweiteren ist function trafo ein wenig zu überarbeiten, anstatt einen Parameter scale der aus der ersten Version stammt, ein Objekt mit Origin, Translation, Rotation, Punkten und wohl auch lokaler Basis zu nehmen. Naja, die Idee, die ich noch verfolge ist, auf ImageData umzusteigen, und einen einfachen line und fill Algorithmus für zu nutzen, wodurch man Licht und Farbinterpolation möglich macht. Wobei, ich möchte den Gedanken zuende führen, ich denke, daß es trotzdem schnell genug sein wird. fill ist dennoch auszuprobieren, weil ich das sowieso auch noch vorhatte.

Cheap 3-D Interval

root (Edward Gerhold)

cheap3dinterval.html Es sieht besser aus, beide Enden des Intervals bestimmen zu können. Ich habe die Achsen neu gedreht und ausserdem die Einheitslänge der Basis auf 10 festgesetzt.

Cheap 3D Stretch

root (Edward Gerhold)

cheap3dstretch.html Hiermit kann man die Länge der Basisvektoren einstellen.Sie verlängern das Bild in beide Richtung. Womit das nächste Vorhaben schnell klar wird. Eine Perspektive wird in eine Richtung grösser, in die andere kleiner. Hierbei sollte man wie auf Blatt Papier in die x-Achse, die in den Raum zeigt, verkleinern und zum Betrachter vergrössern.

Cheap 3d Projektion

root (Edward Gerhold)

cheap3dbase.html

Ich habe mir dann gerade, als ich noch was für unsere Kaninchen holen war,
auf dem Weg nochmal die Formel durch den Kopf gehen lassen. Die Transformation ist 
also eine nahezu perfekte Projektion. Nichts neues, aber wenn man gleich die 
Matrixschreibweise liest, vielleicht gar nicht so bekannt. Hier mal ein
paar Definitionen. Die Winkel hätte ich auch noch gruppieren können, aber
das ist jetzt Latte.

α := rad(65°)
β := rad(135°)
γ := rad(225°)
ex := { Math.cos(α), Math.sin(α) }
ey := { Math.cos(β), Math.sin(β) }
ez := { Math.cos(γ), Math.sin(γ) }
c := { x, y, z }
X := { ex[0], ey[0], ez[0] }
Y := { ex[1], ey[1], ez[1] }

Die Transformation von 3-D Punkten zu 2-D Punkten ist diese

x' := Σ cnXn
y' := Σ cnYn

Ich denke, wenn man zum Beispiel rotieren will, sollte man das vor der 
Trafo machen, warum ich selbige auch in Projektion umbenennen
würde, da sie nach den Aktionen mit den 3-D Koordinaten stattfindet.

Ich sollte nochmal bemerken, daß man, wenn man die Winkel der Achsen ändert,
und es enger wird, es wirklich enger wird. Das ist allerdings aber auch korrekt so.

In gegenwärtiger Matrixschreibweise als 2x3 Matrix mit den Basisvektoren
sieht das dann wie folgt aus.
Man bedenke, das Kosinus und Sinus ohne Multiplikation mit einer Amplitude
einen Radius von 1 haben.

P = [ Math.cos(α), Math.cos(β), Math.cos(γ);
      Math.sin(α), Math.sin(β), Math.sin(γ) ]

und die Eingabe Koordinate als 3x1 Matrix oder 3-D Vektor
v = [x;y;z]

Die ; stehen dabei für neue Zeile und die , für neue Spalte in den [] wie 
in gängiger Software.

Heraus kommt bei Pv oder 2x3*3x1 ein 2-D Vektor oder auch 2x1 Matrix
Pv = [x';y']

Kurzgefasst sieht das so aus.

	...

	x1 = x * ex[0] + y * ey[0] + z * ez[0];
	y1 = x * ex[1] + y * ey[1] + z * ez[1];
	
	...
    }
    return newPoints;
}

Und bewegen kann man sich so, wie man es von entsprechenden Abbildungen zum
Beispiel der ijk-Notation kennt. In Richtung des Vektors, mit Länge der Koordinatenkomponente
als Radius oder Verlängerung des Vektors. Reihenfolge egal, man kann erst z, dann x,
dann y gehen, oder in jeder anderen Reihenfolge. Das Ergebnis ist die selbe Summe.

cheap3dbase.html

Cheap 3D Pro Demo

root (Edward Gerhold)

Das Dokument ist ein kurzer Hack in das alte Dokument rein. Um die Transformation zu demonstrieren, habe ich Eingabefelder für die Winkel der Achsen und eine Skalierung der Oberfläche mit dem click Ereignis vom Button verbunden.

cheap3dbase.html

Der einfache Code für die Transformation steht einen Beitrag tiefer. Es ist eine Ableitung aus der Mathematik, von Σ en*xn, oder wie man die Multiplikation mit einem Satz Basisvektoren beschreibt. Der Trick ist, dass ich zweidimensionale Basisvektoren nehme, die in die Richtung zeigen, wo ich auf dem Bildschirm lang will. Damit ich keine Zahlen ausdenken muss, wie [1.5, 0.7] (zeigt nach rechts und etwas wenig weit nach oben), habe ich einfach xn * Math.cos(angle<sub>n</sub>) für x multipliziert und xn * Math.sin(angle<sub>n</sub>) für y, den jeweiligen x oder y Teil nach der Multiplikation von der Koordinatenkomponente und dem Basisvektor en zu der resultierenden x' oder y' Koordinate addiert. Ich hatte nach der letzten Version die Vermutung es mal mit der Orthonormalbasis zu probieren. Diese hier ist weder orthonormal, noch orthogonal, aber eine (Normal)Basis. Und zwar eine dreidimensionale Basis für eine zweidimensionale Ebene. Einfacher habe ich mir das noch nie gemacht. Verglichen mit WebGL, OpenGL, und genereller Computergrafik. Wenn man jetzt anstatt Canvas.lineTo ein ImageData Objekt benutzt, kann man sowas wie einen z-Buffer und Farbinterpolation, oder auch Licht, probieren, und vielleicht noch mehr als genug Code sparen. Für einfache Visualisierungen scheint das hier jedenfalls schon zu reichen. Das fill vom Canvas müsste eigentlich sogar noch funktionieren.

Ich freu mich über das Resultat und wünsche euch auch viel Vergnügen.

Cheap 3D Professional

root (Edward Gerhold)

/* 
Multiplikation der Originalkoordinaten mit 2D-Vektoren, und Addition der x*cos(achswinkel) und x*sin(achswinkel) Komponenten zur neuen x' und y' Koordinate
*/

function trafo(points, scale) { var newPoints = []; var x,y,z; var x1, y1; var ex = [Math.cos(rad(65)), Math.sin(rad(65))]; var ey = [Math.cos(rad(135)), Math.sin(rad(135))]; var ez = [Math.cos(rad(225)), Math.sin(rad(225))]; for (var i = 0; i < points.length; i+=3) { x = points[i]; y = points[i+1]; z = points[i+2]; x1 = x * ex[0]; y1 = x * ex[1]; x1 += y * ey[0]; y1 += y * ey[1]; x1 += z * ez[0]; y1 += z * ez[1]; if (scale) { x1*=scale, y1*=scale; } newPoints.push(x1,y1); } return newPoints; }

Defekt

root (Edward Gerhold)

Nachdem vor einem halben Jahr mein refurbished Notebook nach bereits einem Jahr seinen Geist aufgab, beziehungsweise Gebrauchserscheinungen zeigte, daß er sich nach einmaligem Gebrauch für Stunden bis Tage abstellt, bevor er wieder betriebsbereit ist, hat jetzt mein alter Computer, der Pentium III aus einer Büroauflösung (Baujahr 2001) ebenfalls aufgegeben, zumindest ist die IDE Platte hinüber und das alte DVD Rom schon lange, daß ich es ohne fremde Hilfe mit einem Laufwerk und einem Rescue System nicht mehr umgehen kann. IDE DMA Read Error, alle zwei drei Sekunden. Unmöglich was zu starten, abzumontieren oder zu prüfen. So bin ich dann weiter mit meinem neuen Hobby Mathematik beschäftigt. Mittlerweile kenne ich die Lösungen von einigen partiellen Differentialgleichungen auswendig. Heute morgen habe ich Trigonometrie wiederholt, und musste bemerken, daß es hängen blieb, denn das auflösen der Identitäten bereitete mir keine Probleme. Im Gegenteil, ich war schneller als beim letzten mal. Aber auch in anderen Teilen der Mathematik mache ich rigorose Fortschritte und besonders Stolz bin ich auf meinen Einstieg in die Quantenmechanik. Mittlerweile kenne ich die Schrödingergleichung für verschiedene Anwendungsfälle und habe meinen Spaß damit. Da ich nun keinen funktionierenden Computer mehr habe, lasse ich das Programmieren aber erstmal was ruhen. Bei meinen Möglichkeiten vielleicht etwas länger ;-)

ES6 - destructuring, block scope, generators, modules, ...

root (Edward Gerhold)

Final Draft

This is the final draft of ECME-262 6th Edition, The 2015 ECMAScript Language Specification. This draft has been submitted to the Ecma General Assembly members for their review and consideration. The GA will vote on approving it as a Ecma standard at their June 2015 meeting.

Assuming GA approval, it will still be possible to make very minor editorial corrections in the published version. So, please continue to report any bugs or typos at bugs.ecmascript.org

April 14, 2015 Rev 38 Final Draft

doc
pdf, no change markup pdf with rev38 change markup
Changes marked as “Rev 38“. Change markup is relative to Release Candidate 4 (Rev37).

Changes include:

  • Tweaked completion value generation for iteration statements to enable loop unrolling.
  • Resolved bugs: 4279, 4274-4269, 4266-4258, 4256-4254, 4252-4248, 4133

Release Candidate Drafts

Development of the ECME-262 6h Edition, The 2015 ECMAScript Language Specification is complete. All that remains to find and fix and remaining editorial or technical bugs in the document.
Please report any bugs or typos at bugs.ecmascript.org

April 3, 2015 Rev 37 Release Candidate 4

doc, this is release candidate 4 with cumulative markup
pdf, no change markup pdf with rev37 change markup pdf with cumulative change markup
Changes marked as “Rev 37“. Change markup is cumulative starting with Release Candidate 1 (Rev34).

Changes include:

  • Various formatting tweaks and editorial and technical bug fixes.
  • Resolved bugs: 4247-4242, 4241-4240, 4238-4213, 4211-4202, 4200-4192, 4191-4185, 4183-4169, 4133

March 17, 2015 Rev 36 Release Candidate 3

doc, this is release candidate 3 with cumulative markup
pdf, no change markup pdf with rev36 change markup pdf with cumulative change markup
Changes marked as “Rev 36“. Change markup is cumulative starting with Release Candidate 1 (Rev34).

Changes include:

  • Several significant fixes relating to “completion reform”
  • Various formatting tweaks and minor editorial and technical bug fixes.
  • Resolved bugs: 4167-4166, 4163=4154, 4151=4148, 4145-4144, 4142, 4139-4125, 4123-4109, 4066, 3618, 3442, 1274, 522

March 4, 2015 Rev 35 Release Candidate 2

doc, this is release candidate 2 with rev35 change markup
pdf, no change markup pdf with rev35 change markup
Changes marked as “Rev 35“. Change markup is cumulative starting with Release Candidate 1 (Rev34).

Changes include:

  • Reverted back to no legacy RegExp.proptotype recognition in RegExp.prototype.exec and test
  • Eliminated buggy exotic [[Enumerate]] for String and Integer Indexed exotic objects. Tweaked ordinary [[Enumerate]] so it will work for them
  • Eliminate ambiguous optional tag on semicolon in do-while statement grammar. Added ASI rule to handle the case where that semicolon is missing.
  • Various formatting tweaks and minor editorial and technical bug fixes.
  • Resolved bugs: 4107-4104, 4101-4099, 4097-4096, 4094, 4091-4089, 4087-4084, 4082-4043, 4041-020, 4018-4013, 4000, 3993, 3989, 3979, 3965, 3865, 1223

February 20, 2015 Rev 34 Release Candidate 1

doc, this is release candidate 1 with with no change markup doc, this is release candidate 1 with cumulative markup
pdf, no change markup pdf with rev34 change markup pdf with cumulative change markup since rev22
Changes marked as “Rev 34“.

Changes include:

  • For legacy compatibility, Array.prototype goes back to being an Array exotic object (Array.isArray(Array.prototype) answers true).
  • For legacy compatibility, RegExp.prototype.exec.call/test.call act as if %RegExpPrototype% was still an RegExp instance
  • TypedArray slice, copyWith, set(TypedArray) do encoding preserving (memcopy) transfers when the source and target element types are the same.
  • The ‘next’ method of internally generated list iterator objects and the ‘revoke’ method of the object returned by Proxy.revocable are now non-enumerable, consistent with other built-in methods
  • Renamed Put() abstract operation to Set()
  • Eliminate the [lexical goal] grammar annotation. Instead clarified the explanation of lexical goals in clause 11
  • Eliminated Annexes D.2, D.3, E.2 that copying the ES5/51 Annex D/E into ES6. Too confusing because of section number mismatches. People should just look at Annex D/E of Es 5/5.1
  • Resolved bugs: 4012, 4010, 4005- 4002, 3999, 3995-3992, 3990-3985, 3983-3935, 3933- 3931, 3929-3902, 3900-3880, 3878-3861, 3859-3858, 3856-3846, 3791, 3759, 3753, 3751-3746, 3724, 3694, 3596, 3504, 3490, 3294, 3279, 3138-3137, 3114, 3074, 2916, 2401, 2215, 1801, 1782, 1778, 1770, 1522-1521, 1075, 1059, 635, 172, 116

Quanten

root (Edward Gerhold)

Gestern und vorgestern habe ich meine ersten Aufgaben der Quantenmechanik gelöst.

 Insbesondere die Schrödingergleichung, die Wellenfunktion, rechnen mit ket- und bra und relativen Wahrscheinlichkeiten sowie Systemzuständen,. erzeugen von Hamilton-Operatoren und Matrixmultiplikation, einsetzen von anderen Operatoren, wie Zustand erhöhen oder erniedrigen. Alles in allem ein Sprung ins kalte Wasser und eine Denknuss nach der anderen. Aber es ist machbar.

Natürlich setze ich das fort, wo ich mich bereits für ein an die Mathematik anschliessendes Selbststudium von Physik, Chemie und auch Wirtschaft entschieden habe.

Hehe, ich hab noch mehr Aufgaben :)

Kopfrechner

root (Edward Gerhold)

Mittlerweile habe ich einige numerische Verfahren handschriftlich ausgerechnet.

Und auch Integraltransformationen habe ich mir beigebracht.

Gerade übe ich Differentialgleichungen ausrechnen. Natürlich ohne Taschenrechner. 

Jetzt sind die Übungsblätter der letzte Hit. 

Lücken stopfen

root (Edward Gerhold)

Heute frisch aus dem Drucker:

Lineare Integralgleichungen

Variationsrechung

Ich habe hier noch Nachholbedarf.

Muss erstmal gucken, ob die PSB auf hat, damit ich lochen und einen Heftstreifen reinstecken kann.

Werde natürlich primär mit der Numerik weitermachen. Ich hatte das geschrieben, weil es Zeit ist, damit fertig zu werden.