Rework me on GitHub   
In memory of our beloved Pünktchen (2009-2015)

Progressive

root (Edward Gerhold)

Mechanik wird immer leichter und immer zusammenhängender. Die Summenkonvention sitzt jetzt. Die Tensoren kann ich anwenden und damit T und V für mechanische Systeme, wie zum Beispiel Oszillatoren aufschreiben. Die Raumzeit und den metrischen Tensor habe ich ebenso verstanden wie unheimlich wichtige Details der Theorien. Ebenso entusiastisch wie ich Mathematik studiere fahre ich zur Zeit mit der Physik fort. Ich kann die ersten Gesetze der Thermodynamik ebenso, wie den Begriff Entropie erklären, oder die fundamentalen Variabeln zu erklären und die Legendre Transformation für die Umwandlung der charakteristischen Oberflächen, auch thermodynamische Potentiale genannt. Ich mache Fortschritte, kann Konfigurationsraum unterscheiden vom Phasenraum, und diese wiederrum vom Mü-Raum und vom Gamma-Raum, sowie einige andere Dinge. Mir fällt eine Menge programmierbarer Code zu ein. Und an meinem Dokument über Koordinatenfunktionale (vielleicht Basisfunktionale) arbeite ich nun auch wieder weiter. Im Entwurf sind viele Tipp-Fehler, oder nur angefangene Abschnitte, wenn auch ausführlicher. ES ist unvollständig und es gibt ein paar Passagen aus dem ersten Entwurf die gar ganz raus müssen. Die Beweise muss ich ausserdem noch alle hinzufügen. Was ich übrigens auch erlernt habe. Inzwischen habe ich mich eine Weile mit Strom und Elektrodynamik beschäftigt und bin in der Lage mit der Ladung, Spannung, Stärke und verschiedenen Bauteilen zu rechnen, da ich wirklich geübt habe. Es macht Spass. Und danch ist die Chemie dran. Und wenn ich Pech habe bin ich dennoch schneller mit meinen Gründungsratgebern wiederholt fertig und im Kiosk statt irgendwo angestellt worden, weil keiner aufmerksam (gemacht) wurde. Übrigens habe ich gestern einen Beat für ein neues Raplied zusammengestellt. Ich denke, mal wieder was neues zusammenstellen zu wollen. Mal schauen.

EcmaScript 6 closing up

root (Edward Gerhold)

Habe gerade den Es6 status mit dem kangax table kontrolliert, da der als einzige aktuelle Quelle bemerkbar ist. https://kangax.github.io/compat-table/es6/ Man kann jetzt getrost auf es6 umsteigen.

 

Genius in preparation

root (Edward Gerhold)

Hätte man mir Mathematik, Chemie, Physik früher in der Sekundarstufe I schmackhafter gemacht, hätte ich vielleicht nie blau gemacht. (Wodurch meine Alten trotzdem nicht weniger Schuld haben, als sie haben.) Ich habe nicht nur riesigen Spass und keinerlei Probleme zu verstehen. Da ich seit Ende ´14 mehr Mathematikstunden genommen habe, als ein Schüler im Jahr Unterricht hat, habe ich mittlerweil, ausser dem Stoff weiter als das Abitur gebracht, auch meine Gedächtnisleistung enorm verbessert. Gerade lerne ich die relevanten Themen der Physik. Zum einen aus der Schule, so wie in der Schule, vorzugsweise mit Physik für Dummies, in der eindimensionalen Fassung, zum anderen natürlich mit richtigen Büchern über klassische Mechanik, Elektrodynamik, Quantenmechanik, und weiteren Themen. Mit der Chemie habe ich auch begonnen und kann bereits mehr, als ich zur Schulzeit konnte. Ich machte den Unterricht irgendwann nur noch blau. Man vergass mir die Relevanz der Inhalte für das spätere Studium schmackhafter zu machen. Zuhause gab es keine Förderung, keine Nachhilfe, keine Ämter, die die Eltern ausübten, so übte auch ich keins in der Schule aus und wurde kein Streber. Ich wollte Informatiker oder Ingenieur werden. Zwanzig Jahre später studiere ich alles von vorne. Aber mit unglaublichem Erfolg. In Mathematik habe ich den Abiturstoff von Infinitesimalrechung, Differentialgleichungen, linearer Algebra und Stochastik noch ein ganzes Stück weiter gebracht. In Physik und Chemie übertreffe ich meine Schulleistungen bereits. Anders als zu Schulzeiten, wo man nichtmal die Newtonschen Bewegungsgleichungen vernünftig vorstellte, als Newton drankam, sonst wäre mir damals schon ein Licht aufgegangen, bin ich heute Fan von Trägheit, Kaft, Moment, Winkelgeschwindigkeit, Drehmoment, und weiteren wichtigen Formeln, der Lagrangefunktion, bis zum Hamilton und so weiter. Ich habe mittlerweile gute Bücher über klassische Mechanik, und andere gute Physikbücher. Ich bin jetzt auch fit, um mit Strom zu arbeiten und bereits knapp hundert Übungsaufgaben gerechnet und die Sache aufmerksam mitverfolgt. Habe Linsen und Spiegel ebenso wiederholt, wie Schallgeschwindigkeit und Brechung, Interferenz, Reflektion von Wellen in verschiedenen Medien. Anders als zur Schulzeit habe ich die Welle verstanden, die mir zuhause auffiel, als ich Ende der Neunziger hellwach die Nacht neuen modernen unglaublich guten Hiphop machte, ich aber nicht wusste, was ich da suchte. Aber nicht nur die Welle. Seit ich Mathematik gelernt habe, geht mir hier alles leicht von der Hand. Und nach den Naturwissenschaften, beziehungsweise demnächst, überarbeite ich besonders meine wirtschaftlichen Kompetenzen, aber auch meine sozialen. Oh, ich muss unterbrechen. Meine Frau... Grüße

 

Strom bestimmen

root (Edward Gerhold)

Daß mich Elektrizität und Magnetismus mehr packt, als zur Schulzeit hatte ich erwartet. Nun kann ich nach einer Weile bereits mit der elektrischen Ladung umgehen. Ich verstehe das Ohmsche Gesetz und die vom Kirchhoff, das Coloumbsche Gesetz, und kann statische Elektrizität, sowie Gleichstrom und Wechselstrom unterscheiden. Ich kann, wie gerade bereits anders gesagt, Reihen- und Parallelschatungen ausrechnen. Dafür habe ich mehrere Aufgaben gemacht. Der Wechselstrom macht mir keine Sorgen und ich habe auch bereits Phasen zwischen Spulen, Kondensatoren und Widerständen bestimmt. Die Spule, den Kondensator, den Widerstand und die RLC Kombination habe ich durchgenommen. Geübt habe ich mit den diskreten Fassungen der elektrischen Formeln. Die analytische Version der Elektrodynamik allerdings, die ich bereits vorbereitet habe, erscheint mir nun im neuen Licht, da es natürlich um den selben Strom geht und so meistere ich gerade den Übergang von der Schulphysik zur kontinuierlichen Elektrodynamik. Alles in allem ein Erfolg und ich fahre damit fort. Heute morgen habe ich ausserdem Einstein für Dummies halb gelesen, nachdem ich String-Theorie für Dummies las, und mir das Standardmodell der Teilchenphysik nochmal genau habe erklären lassen, bevor es zurück zur Mathematik geht... Ich denke mit dem Strom kann ich mir als IT natürlich helfen. Phosphor und Silikon ergeben N-Halbleiteer (ein Elektron frei) und z.B. Boron und Silikon ergeben einen P-Halbleiter (ein Loch im Silizium), womit der Übergang zur Elektrotechnik und Elektronik in beiderlei Hinsicht ebenfalls von mir genommen werden kann. Wünsche euch ebenfalls viel Vergnügen.

Integralgleichungen

root (Edward Gerhold)

Nachdem ich bei den theoretischen Physikern fündig wurde und mein lange gesuchtes Buch über Integralgleichungen fand, habe ich gleich mitgerechnet und meine ersten Fredholmschen und Volterraschen Integralgleichungen gelöst. Beim ersteren mit Substitution des Integrals und Einsetzen der neuen Funktion in das Integral und danach Auflösen des Buchstabens, womit die Sache dann erledigt ist, je nachdem, welchen Wert lambda dann hat. Die Fredholmsche Alternative, daß man wenn die nichttriviale Lösung unmöglich ist, eine eindeutige Lösung hat, wird gleich mit beigebracht. Bei Volterra wurde differenziert und integriert, um die Integralgleichung zu lösen. Weiter kennengelernt habe ich die iterierten Integralgleichungen. Bei Hilbert-Schmidt findet man sich in der Welt der mehrdimensionalen Vektorräume und orthogonalen Funktionen wieder und stellt erstmal die Symmetrie des Kernels fest, und dass die adjungierte Gleichung praktisch identisch ist, also dass Ding wieder mal selbstadjungiert ist. Dann wird für k(x,y) der Hilbert-Schmidt Kernel gewählt, der p(x)_n*p(y)_n/lambda_n oder die n-te Eigenfunktion jeweils mit x und mit y gerufen multipliziert geteilt durch den n-ten Eigenwert ist. Ihr dürft raten. Das gibt es auch als Sequenz. Die Eigenfunktionen sind orthogonal zueinander, so ergeben die gleichen miteinander gleich null, wie man es von den Sinus-und-Kosinus Integralen von den Fourierreihen kennt, so funktioniert das auch hier. Das ganze geht noch weiter, ist mittelschwer nachzuvollziehen, also alles andere als schwierig und bemerkenswert ist, daß ich den selben Hilbert-Schmidt Sachverhalt in einem Buch über Funktionalanalysis so schwach geboten bekam, daß ich es glatt überlesen habe, wie ich damit rechne. In dem Buch über angewandte Mathematik in der theoretischen Physik, was bis auf zwei Kapitel Variationsrechnung am Ende nur Integralgleichungen behandelt und kein sechstes Kapitel im Dokument hat, was mich enttäuschte, da in Kapitel 7 dann Methoden aus 6.1 und 6.3 und 6.4 zu Beginn eingesetzt werden, wird alles praktisch gezeigt, daß mir Integralgleichungen seit einigen Tagen richtig Spass machen, während ich fleissig Physik und Chemie Büffel um wie in Mathe aufzuholen. Nach über 50 Tagen hat sich der defekte Computer verabschiedet. Nach zwei Tagen ging er wieder einzuschalten. Ich habe in Sachen Strom, Gleichstrom, Wechselstrom, in Physik endlich das Schulwissen wiederholt und kann das Ohmsche Gesetz wieder, was in der Schule die Grundlage für die Stromkreise bietet. Ich konnte das Gauschsche Gesetz für elektrische und magnetische Felder übrigens schon letztes Jahr integrieren, konnte mich aber nicht mehr an die alten Regeln erinnern, die ich mit etwas Mühe dann wieder entdeckt habe. Ich lerne weiter und freue mich schon auf die nächste Stunde morgen. Jetzt habe ich nicht alles fortgesetzt, die Hilbert-Schmidt Kerne haben die Eigenschaft, auch zu gelten, wenn man nicht weiss, ob der Satz Eigenfunktionen komplett ist.

Homepage Provisorium

root (Edward Gerhold)

Ich habe mein Projekt Homepage seit 2014 nicht fortgesetzt. Das Framework aus dem Buch Pro PHP MVC was darunterliegt ist einfach zu erweitern und nicht das Problem. Erst ging der Computer kaputt, dann habe ich von der Informatik abgelassen und Mathematik studiert.

 

exports.create2x3adjoint3 = create2x3adjoint3;
exports.create2x3adjoint2 = create2x3adjoint2;

function create2x3adjoint3(operator) {
    var ex_x = operator[0],
        ex_y = operator[1],
        ey_x = operator[2],
        ey_y = operator[3],
        ez_x = operator[4],
        ez_y = operator[5];
    var adjoint = new ARRAY_TYPE(operator.length);
    // 3x2 * 2x3 = 3x3
    adjoint[0] = ex_x*ex_x + ex_y*ex_y;
    adjoint[1] = ex_x*ey_x + ex_y*ey_y;
    adjoint[2] = ex_x*ez_x + ex_y*ez_y;
    adjoint[3] = ey_x*ex_x + ey_y*ex_y;
    adjoint[4] = ey_x*ey_x + ey_y*ey_y;
    adjoint[5] = ey_x*ez_x + ey_y*ez_y;
    adjoint[6] = ez_x*ex_x + ez_y*ex_y;
    adjoint[7] = ez_x*ey_x + ez_y*ey_y;
    adjoint[8] = ez_x*ez_x + ez_y*ez_y;
    return adjoint;
}

function create2x3adjoint2(operator) {
    // 2x3 * 3x2 = 2x2
    var ex_x = operator[0],
        ex_y = operator[1],
        ey_x = operator[2], 
        ey_y = operator[3],
        ez_x = operator[4],
        ez_y = operator[5];
    var adjoint = new ARRAY_TYPE(4);
    adjoint[0] = ex_x*ex_x+ey_x+ey_x+ez_x+ez_x;
    adjoint[1] = ex_y*ex_x+ey_y+ey_x+ez_y+ez_x;
    adjoint[2] = ex_x*ex_y+ey_x+ey_y+ez_x+ez_y;
    adjoint[3] = ex_y*ex_y+ey_y+ey_y+ez_y+ez_y;
    return adjoint; 
}

 

Meine letzten Gedanken zum Thema 3-D nach 2-D, was von den drei 2-D Achsen am Kreis, die das mathematische Äquivalent zu dem auf Papier gemalten 3-D Koordinatensystem darstellen, sind zu einem Bestand der Funktionalanalysis geworden. Aufgrund der gesamten Organisation unseres Privatlebens ist inzwischen die Andeutung Koordinatenfunktionale und n-dimensionale Abbildungen in m Dimensionen (mit m < n) geworden.

 

function transform2x3(operator, x) {
    var y = new ARRAY_TYPE(2);
    y[0] = operator[0]*x[0]+operator[2]*x[1]+operator[4]*x[2];
    y[1] = operator[1]*x[0]+operator[3]*x[1]+operator[5]*x[2];
    return y;
}
function transform3x2(operator, w) {
    var y = new ARRAY_TYPE(3); 
    y[0] = operator[0]*w[0]+operator[3]*w[1]
    y[1] = operator[1]*w[0]+operator[4]*w[1]
    y[2] = operator[2]*w[0]+operator[5]*w[1]
    return y;
}

exports.transform3x2 = transform3x2;
exports.transform2x3 = transform2x3;

function transform2x3All(operator, X) {
    var Y = [], v,w,x,y,z;
    var o0=operator[0],
        o1=operator[1],
        o2=operator[2],
        o3=operator[3],
        o4=operator[4],
        o5=operator[5];
    for (var i = 0, j = X.length; i < j; i++) {
        w = new ARRAY_TYPE(2);
        v = X[i],
        x = v[0],
        y = v[1],
        z = v[2];
        w[0] = o0*x+o2*y+o4*z;
        w[1] = o1*x+o3*y+o5*z;
        Y.push(w);
    }
    return Y;
}

exports.transform2x3All = transform2x3All;

 

Ich habe die letzten Wochen Differentialgleichungen geübt, und als ich über Newtons Gesetz der Abkühlung philosophierte, dachte ich daran, mal Thermodynamik zu probieren. Das habe ich im Anschluss gemacht, und gleich weitere Themen der Physik angesprochen. Elektrodynamik, was ich in Form der Maxwell-Gleichungen schon eine Weile vorbereitet habe, kommt gleich nach dem Klassiker "Classical Mechanics" vom Goldstein dran. In der klassischen Mechanik lerne ich gerade die analytischen Formulierungen von Koordinaten und Momenten, lokalen Achsen und Festkörperversetzung. Die Informatiker kennen das von der Computergrafik, die Mathematiker aus linearer Algebra und die Physiker, die liefern die Lösung.

 

function change2x3ByDomain(operator, domain) {
    var ex_x = operator[0],
        ex_y = operator[1],
        ey_x = operator[2],
        ey_y = operator[3],
        ez_x = operator[4],
        ez_y = operator[5];
    var dx_x = domain[0], 
        dx_y = domain[1],
        dx_z = domain[2];
    var dy_x = domain[3], 
        dy_y = domain[4],
        dy_z = domain[5];
    var dz_x = domain[6], 
        dz_y = domain[7],
        dz_z = domain[8];
    var newOperator = new ARRAY_TYPE(operator.length);
    // update e_x with the x axis of the domain
    newOperator[0] = ex_x*dx_x + ey_x*dx_y + ez_x*dx_z;
    newOperator[1] = ex_y*dx_x + ey_y*dx_y + ez_y*dx_z;
    // update e_y with the y axis of the domain
    newOperator[2] = ex_x*dy_x + ey_x*dy_y + ez_x*dy_z;
    newOperator[3] = ex_y*dy_x + ey_y*dy_y + ez_y*dy_z;    
    // update e_z with the z axis of the domain
    newOperator[4] = ex_x*dz_x + ey_x*dz_y + ez_x*dz_z;
    newOperator[5] = ex_y*dz_x + ey_y*dz_y + ez_y*dz_z;
    return newOperator;
}
  
function change2x3ByRange(operator, range) {
    var ex_x = operator[0],
        ex_y = operator[1],
        ey_x = operator[2],
        ey_y = operator[3],
        ez_x = operator[4],
        ez_y = operator[5];
    var rx_x = range[0],
        rx_y = range[1],
        ry_x = range[2],
        ry_y = range[3];
    var newOperator = new ARRAY_TYPE(operator.length);
    // x row (same oriented) of range with column (axis) of operator
    newOperator[0] = rx_x*ex_x + ry_x*ex_y;
    newOperator[1] = rx_x*ey_x + ry_x*ey_y;
    newOperator[2] = rx_x*ez_x + ry_x*ez_y;
    // y row (same oriented) of range with column (axis) of operator
    newOperator[3] = rx_y*ex_x + ry_y*ex_y;
    newOperator[4] = rx_y*ey_x + ry_y*ey_y;
    newOperator[5] = rx_y*ez_x + ry_y*ez_y;
    return newOperator;
}

exports.change3x2ByRange = change3x2ByRange;
function change3x2ByRange(operator, range) {
    var ex_x = operator[0],
        ex_y = operator[1],        
        ex_z = operator[2],
        ey_x = operator[3],        
        ey_y = operator[4],
        ey_z = operator[5];
    var rx_x = range[0],
        rx_y = range[1],
        ry_x = range[2],
        ry_y = range[3];
    var newOperator = new ARRAY_TYPE(operator.length);
    newOperator[0] = ex_x * rx_x + ey_x * rx_y;
    newOperator[3] = ex_x * ry_x + ey_x * ry_y;
    newOperator[1] = ex_y * rx_x + ey_y * rx_y;
    newOperator[4] = ex_y * ry_x + ey_y * ry_y;
    newOperator[2] = ex_z * rx_x + ey_z * rx_y;
    newOperator[5] = ex_z * ry_x + ey_z * ry_y;    
    return newOperator;   
}

exports.change3x2ByRange = change3x2ByRange;
exports.change2x3ByDomain = change2x3ByDomain;
exports.change2x3ByRange = change2x3ByRange;

 

Alles in allem habe ich eine Reihe schrottiger Posts gelöscht, wenn auch gleich der Rest Kandidat wäre. Das Homepage Provisorium bietet ein paar Ansätze, die vielleicht mal gefunden oder gar gelesen werden. Leider verweigert mir das Arbeitsamt einen Kurs mit LPIC-Zertifizierung, wie auch jeden anderen Kurs, daß ich auf selbst lernen angewiesen bin, wie auf Hilfe von anderen, daß ich noch dreissig und mehr Jahre für andere arbeiten kann. Aber seit ich Mathematik studiere, bin ich zuversichtlich, es doch noch zu schaffen, wartet vielleicht auch noch eine Platinplatte darauf, mit höchstem Anspruch und höchster Sorgfalt verwirklicht zu werden.

 

exports.create3x2MoorePenrose = create3x2MoorePenrose;
function create3x2MoorePenrose(operator) {    
    var At = transpose2x3(operator);
    var AAt = create2x3adjoint2(operator);
    var a11 = AAt[0],
        a21 = AAt[1],
        a12 = AAt[2],
        a22 = AAt[3];
    var det = (a11*a22-a12*a21);
    if (det===0) throw new TypeError("zero determinant of the 2x2 adjoint");
    var AAtinv = new AAt.constructor(4);
    AAtinv[0] = a22/det;
    AAtinv[1] = (-a12)/det;
    AAtinv[2] = (-a21)/det;
    AAtinv[3] = a11/det;
    return change3x2ByRange(At, AAtinv);
}

 

Einen Kiosk oder gar ein IT-Startup kann ich vergessen. Eine Reihe Posts, was ich alles in den Wochen Tag für Tag neu erlernt habe, da ich jeden Tag stundenlang mathematische Zusammenhänge büffel, wie in Zukunft auch Naturkräfte und ihre molekularen Verhältnisse (Chemie meine ich), habe ich gelöscht.

 

ODETools.prototype = {
   
    firstSymmetricDifference: function (f, x, h) {
        if  (h===0) return;
        return (f(x+h)-f(x-h))/(2*h)
    },
    firstDifference: function (f, x, h) {
        if  (h===0) return;
        return (f(x+h)-f(x))/(h)
    },
    secondDifference: function (f,x,h) {
        if  (h===0) return;
        return (f(x+h)+f(x-h)-2*f(x))/(h*h);
    },
    euler: function (f, x0, xn, y0, h) {
        var points = [];
        var steps = ( xn - x0 )/h;
        var x = x0, y = y0;
        while (steps-- > 0) {
            y = y+h*f(x,y);           
            points.push([x,y]);
            x = x+h;
        }
        return points;
    },
    improvedEuler: function (f,x0,xn,y0,h) {
        var k1, k2;

        var points = [];
        var steps = ( xn - x0 )/h;
        var x = x0, y = y0, u, k1, k2;
        while (steps-- > 0) {
            k1 = f(x,y);
            u = y+h*k1;
            k2 = f(x+h, u);
            y = y+h*0.5*(k1+k2);           
            points.push([x,y]);
            x = x+h;
        }
         
        return points;
    },
    rungeKutta: function (f,x0,xn,y0,h) {
        var k1,k2,k3,k4;
        var points = [];
        var steps = ( xn - x0 )/h;
        var x = x0, y = y0;
        while (steps-- > 0) {
            k1 = f(x,y);
            k2 = f(x+0.5*h,y+0.5*h*k1);
            k3 = f(x+0.5*h,y+0.5*h*k2);
            k4 = f(x+h,y+h*k3);
            y = y + h/6 * (k1+2*k2+2*k3+k4)
            points.push([x,y]);
            x = x+h;
        }
        return points;
    },
    eulerSystem: function (F, x0, xn, y0, h) {
        var system = [];
        var points;
        var steps = ( xn - x0 )/h;
        var step;
        var x = x0, y = y0;
        var f;
        for (var i = 0, j = F.length; i < j; i++) {           
            points = [];
            system.push(points);
            step = steps;
            f = F[i];
            while (step-- > 0) {
                y = y+h*f(x,y);           
                points.push([x,y]);
                x = x+h;
            }
        }
        return system;

    },
    improvedEulerSystem: function (f,x0,xn,y0,h) {
        var k1, k2;
        var system = [];
        var points;
        var steps = ( xn - x0 )/h;
        var step;
        var x = x0, y = y0;
        var f;
        for (var i = 0, j = F.length; i < j; i++) {           
            points = [];
            system.push(points);
            step = steps;
            f = F[i];
            while (step-- > 0) {
                k1 = f(x,y);
                u = y+h*k1;
                k2 = f(x+h, u);
                y = y+h*0.5*(k1+k2);           
                points.push([x,y]);
                x = x+h;
            }
        }
        return system;
    },
    rungeKuttaSystem: function (f,x0,xn,y0,h) {
        var k1,k2,k3,k4;

        var system = [];
        var points;
        var steps = ( xn - x0 )/h;
        var step;
        var x = x0, y = y0;
        var f;

        for (var i = 0, j = F.length; i < j; i++) {           
            points = [];
            system.push(points);
            step = steps;
            f = F[i];
            while (step-- > 0) {
                k1 = f(x,y);
                k2 = f(x+0.5*h,y+0.5*h*k1);
                k3 = f(x+0.5*h,y+0.5*h*k2);
                k4 = f(x+h,y+h*k3);
                y = y + h/6 * (k1+2*k2+2*k3+k4)
                points.push([x,y]);
                x = x+h;
            }
        }
        return system;       
    }

};

 

 

Habe allerdings viel viel Code den Monat über geschrieben, alles, was am Computer simulierbar ist, auch vorzubereiten.

Hilfsklassen die nicht fertig sind, gibt es auch. FastGUI spart Variabeln für jede Datei indem sie einen Cache Eintrag des Input Elements wrappt.

 

    
    function FastGUI() {
        this.elems = Object.create(null);
    }

    FastGUI.prototype = {

        addElement: function(tag, id, parent, props) {
            var elem = document.createElement(tag);
            elem.id = id;            
            if (typeof parent === "string") parent = document.getElementById(parent);
            if (typeof props === "object" && props) Object.keys(props).forEach(function (key) {
                elem[key] = props[key];
            });
            parent.appendChild(elem);
            this.elems[id]=elem;
            return elem;
        },

        addTextInput: function ( id, parent, label, props, props_label) {
            var label = this.addElement("label", id+"_label", parent, mixin({ "for": id }, props_label));
            return this.addElement("input", id, label, mixin({ type: "text", label: id+"_label" }, props));
        },
        
        addNumberInput: function (id, parent, label, props, props_label) {
            var label = this.addElement("label", id+"_label", parent, mixin({ "for ": id }, props));
            return this.addElement("input", id, label, mixin({ type: "number" }, props));
        },

        addCanvas: function (id, parent, props) {
            var can = this.addElement("canvas", id, parent, props)            
            return can;
        },

        get2dContext: function (id, callback) {
            var ctx = this.elems[id+"_2dcontext"];
            if (!ctx) {
            	if (!this.elems[id]) this.elems[id] = document.getElementById(id);
            	ctx = this.elems[id+"_2dcontext"] = this.elems[id].getContext("2d");
            }            
            if (ctx && callback) callback(ctx)
            return ctx;
        },
        
        getElement: function (id, callback) {
        	var elem = this.elems[id];
			if (!elem) (elem = this.elems[id] = document.getElementById(id));
			if (elem && callback) callback(elem);
			return elem;
        },

        docById: function (id) { 
        	return document.getElementById(id) 
        },

        getValue: function (id) {
            var elem = this.elems[id];
            if (elem) return elem.value;
        },

        setValue: function (id, value) {
            var elem = this.elems[id];
            if (elem) elem.value = value;
        },

        addEvent: function (id, eventname, callback) {
            var elem = this.elems[id];
            if (elem) elem.addEventListener(eventname, callback);
        }

    };


exports.FastGUI = FastGUI;

		// WebAudio 

		function ContextExtension2x3(context, basis) {
			
			"use strict";
			
			var ex_x, ex_y, ey_x, ey_y, ez_x, ez_y;
			this.basis = basis;
			this.context = context;
			
			ex_x = basis[0];
			ex_y = basis[1];
			ey_x = basis[2];
			ey_y = basis[3];
			ez_x = basis[4];
			ez_y = basis[5];

			function lineTo3(point) {
				var x = point[0];
				var y = point[1];
				var z = point[2];
				var x_ = ex_x * x + ey_x * y + ez_x * z;
				var y_ = ex_y * x + ey_y * y + ez_y * z;
				context.lineTo(x_,-y_);
			}

			function moveTo3(point) {
				var x = point[0];
				var y = point[1];
				var z = point[2];
 				var x_ = ex_x * x + ey_x * y + ez_x * z;
				var y_ = ex_y * x + ey_y * y + ez_y * z;
				context.moveTo(x_,-y_);
			}

			function drawClosedPath(points, fill) {
				context.save();				
				var x,y,z,p,x_,y_;
				var x0_,y0_;
				p = points[0];
				x=p[0],y=p[1],z=p[2];
				x0_ = ex_x * x + ey_x * y + ez_x * z;
				y0_ = ex_y * x + ey_y * y + ez_y * z;
				context.moveTo(x0_,-y0_);
				context.beginPath();

				for (var i = 1, j = points.length; i < j; i++) {
					p = points[i];
					x=p[0],y=p[1],z=p[2];
					x_ = ex_x * x + ey_x * y + ez_x * z;
					y_ = ex_y * x + ey_y * y + ez_y * z;
					context.lineTo(x_,-y_);
					context.moveTo(x_,-y_);					
				}
				
				context.lineTo(x0_,-y0_);
				context.moveTo(x0_,-y0_);	
				context.closePath();
				context.stroke();
				if (fill) context.fill();
				context.restore();

			}
			
			this.lineTo3 = lineTo3;
			this.moveTo3 = moveTo3;
			this.drawClosedPath = drawClosedPath;
			return this;
		
		}

		function lineTo3(context, point, basis) {
			var x = point[0];
			var y = point[1];
			var z = point[2];
			var ex_x = basis[0];
			var ex_y = basis[1];
			var ey_x = basis[2];
			var ey_y = basis[3];
			var ez_x = basis[4];
			var ez_y = basis[5];			
			var x_ = ex_x * x + ey_x * y + ez_x * z;
			var y_ = ex_y * x + ey_y * y + ez_y * z;
			context.lineTo(x_,-y_);
		}

		function moveTo3(context, point, basis) {
			var x = point[0];
			var y = point[1];
			var z = point[2];
			var ex_x = basis[0];
			var ex_y = basis[1];
			var ey_x = basis[2];
			var ey_y = basis[3];
			var ez_x = basis[4];
			var ez_y = basis[5];
			var x_ = ex_x * x + ey_x * y + ez_x * z;
			var y_ = ex_y * x + ey_y * y + ez_y * z;
			context.moveTo(x_,-y_);
		}

 

Ich hab mal einfach wahllos Code reingepostet.

Defekter Computer

root (Edward Gerhold)

linux-dww5:~ # date
Sun Mar 13 18:12:18 CET 2016
linux-dww5:~ # uptime
 18:12pm  up 30 days 20:43,  23 users,  load average: 0.15, 0.07, 0.06
linux-dww5:~ #


Weil der Computer kaputt ist, und nicht mehr angeht, wenn er ausgemacht wird, habe ich ihn laufen lassen. So konnte ich an meiner Mathearbeit arbeiten und an einem Dutzend nützlicher Klassen, sowie noch einem Dutzend didaktisch notwendigem Experimentiercode. Irgendwas ist mit der Temparatursteuerung nicht mehr in Ordnung und ich habe es bislang nicht geschafft, ihn in die Reparatur zu geben.

Determinante rekursiv

root (Edward Gerhold)

Das Summieren einer Determinante einer nxn Matrize erfordert n! Determinanten aus n! Matrizen auszurechnen. Man streicht eine Reihe und eine Spalte, nimmt die Zahl im Kreuz der beiden Abgestrichenen, und aus den verbleibenden Zahlen formt man eine Minor-Matrix. Eine 4x4 Matrize zerfällt in vier 3x3 Matrizen, die in je drei 2x2 Matrizen zerfallen, deren einzahlige Unterdeterminanten nur mit ihrem Koeffizenten multipliziert werden und mit (-1)^i+j eben addiert oder subtrahiert. Wenn der Algorithmus zurückkehrt, wird alles summiert. Das kann man durch entlanglaufen einer Spalte, oder einer Zeile machen. Aufgrund der Matrixordnung im WebGL habe ich die column major Ordnung verwendet, wo die Spalten nebeneinander liegen. Mehr zum Code, dem Algorithmus für den Index, und die Tatsache, daß es keine Bildschirmseite, sondern eine Hand voll Zeilen sind, später, denn ich arbeite gerade (oder nachher, oder morgen) an den Funktionen. Ich denke mal, daß ich so mein Exteriorprodukt dann auch generell auf dem Computer rechnen kann. Und bin froh, die Formel so noch lebendiger im Kopf zu halten, wie ich sie vorher nicht hielt. Ich habs mit handgerechneten Determinanten und Minoren verglichen, es stimmt alles.

2-D -> 3-D Rekonstruktion

root (Edward Gerhold)

Im Spezialfall für den f(x,y,z)=(x,y,z) oder f(x,y)=z Plotter kann man die 3-D rekonstruieren. Wenn man die x oder y Achse zum Beispiel in gleichen Abständen durchläuft, und die delta-Breite kennt, kann man sicher wissen, welche Zahl da dran kommt, dann kann man den Anteil vom 2-D (x,y) abziehen und die neue Gleichung mit zwei Unbekannten korrekt auflösen. So ist es möglich im Fall, daß man wenigstens eine Variable kennt, das ansonsten unlösbare unterbestimmte 2x3 Gleichungssystem als 2x2 System aufzulösen. Bei Plottern, die Punkte in gleichen Abständen nehmen, ist es zum Beispiel möglich, einen gezeichneten Graphen wieder in die Originalpunkte zu verwandeln. Richtige 3-D Rekonstruktion hat natürlich richtige Anwendungen in der realen Welt. Was meinen 2x3 Abbildungssatz betrifft, finde ich, jede Investigation ist es Wert, die Eigenschaften und Möglichkeiten der Abbildungsmatrix (ein kompakter, linearer, surjektiver mxn Operator mit m<n, ohne Inverse, desen Produkt mit der adjungierten, reell transponierten, symmetrisch und da reell sogar selbstadjungiert ist, der mit 2x2 und 3x3 multipliziert die Abbildung oder die Eingabe anpassen kann) zu vervollständigen.

Zerlegung der Eins

root (Edward Gerhold)

Heute habe ich mir Gedanken über die Zerlegung der 1 gemacht. Meine Idee war, sie in eine Reihe von Brüchen zu zerlegen, die monoton wachsen. Ich habe eine Form gefunden, sie in beliebig viele Brüche zu zerlegen. Also in n=3 zerlegt ist das 1/6 + 2/6 + 3/6. Zum Beispiel. Der Trick geht so: Ich nehme die Anzahl der gewünschten Brüche, n, und summiere k von 1 bis n. Wie man weiss, ist die Summe aller k von k=1 bis k=n das selbe wie (n*(n+1))/2. Diese Summe ist somit unser Nenner für unsere zweite Reihe. Die Erste ist die Summe aller k von 1 bis n oder n(n+1)/2, im folgenden N (für Nenner) genannt. Die zweite Reihe lautet einfach Summe k/N von k=1 bis k=n und ist die Zerlegung der Eins.

Danach habe ich überlegt, wie ich eine beliebige Zahl zerlege. Und mit stolpern über die richtige Lösung und, da ich ja nicht mit Zahlen sondern nur geistig und mit mir redend probierte, mehreren Versuchen, eine Form zu finden, bin ich dann drauf gekommen. Nehmen wir an, wir zerlegen die Zahl 17. Dann ist die Summe des Nenners für die zerlegte 1 ja 17(18)/2 = 153. Um den Nenner zu korrigieren, teile ich N=153 nun durch die gewünschte Zahl 17. Heraus kommt 9. Somit ist unsere Reihe 1/9 + 2/9 + 3/9 + ... + 17/9 = 17. Ich kann sie aber auch durch mehr Brüche zerlegen. Vervierfachendes Beispiel. Wir summieren 4*17 = 68 (um die 17 zu zerlegen), die Summe ist 68(69)/2 = N = 2346, N/17 = 138 = Q und unsere Folge (k/Q)k=1...17 ist 1/138, 2/138, ... 68/138 und unsere Summe ist 17. Anstelle wie bei der zerlegten Eins ist noch der Nenner durch die zu zerlegende Zahl zu teilen. Dadurch das wir sie oder ihr vielfaches für den Nenner summiert haben, scheint/ist die Teilung des Nenners durch unsere Zahl immer möglich, da sie immer ein Faktor in n(n+1)/2 ist, da n=x*Z (Anzahl der Brüche pro Einheit unserer Zahl mal unserer Zahl). Beim Überlegen wusste ich noch nicht, daß diese Anpassung des Nenners sicher ist.

So habe ich dann heute noch die Zerlegung der 1 in eine Folge mit aufsteigenden ganzzahligen Zählern mit ganzzahligem Nenner, der die gesamte Summe der Zähler ist, um summiert 1 zu ergeben. Sowie den Fall für die Zerlegung einer beliebigen positiven ganzen Zahl auf eine allgemeine Form gebracht. Das setze ich mir noch als eine oder zwei Din-A4 Seiten mit LaTeX für meine Sammlung.

Hat Spass gemacht, die Lösung zu suchen.

 

--- Samstag, 21.11.15

Update: Das war natürlich nicht korrekt oder komplett. Es funktioniert mit der 1 und mit ungeraden (!) Zahlen wie gesagt. Bei geraden Zahlen hat man eine x,5 Zahl im Nenner. Wenn man mit 2/2 erweitert hat man die Reihe 2/2N + 4/2N, was dann zwar Integer ist, aber nicht die Zählerreihe 1,2,3,4,5,...,n die gesucht war. Intuitiv habe ich dann n+(n-1) eingesetzt. Mit 2n-1 geht jede gerade Zahl dann zu zerlegen. Ich zeig´s mal algebraisch.

Also wenn wir k von 1..2n-1 summieren, haben wir (2n-1)(2n-1+1)/2 = 2n(2n-1)/2 = n(2n-1). Das ist die Summe der monoton wachsenden Zähler von 1..2n-1. Wir müssen noch durch n (gesuchte Zahl) teilen, so bleibt N=2n-1. Das ist möglicherweise der kleinste sinnvolle Nenner um beliebige gerade Zahlen in monoton wachsende Brüche (1/N + 2/N + 3/N + ... + n/N, hier ...+2n-1/N) zu zerlegen. Summieren wir jetzt ((2n-1)(2n)/2) / (2n-1) kommt raus 2n/2 = n. Unsere gesuchte Zahl, die zu zerlegen war.

Also es gibt jetzt drei Fälle für mich, wobei der erste Fall die zerlegte 1 ist. Der zweite Fall ist ungerade Zahlen zu zerlegen, wie zuerst beschrieben. Der dritte Fall, gerade Zahlen brauchen spezielle Behandlung, kam heute hinzu, beim nachprüfen, als ich das setzen wollte. Dabei kam raus, nochmal für gerade Zahlen zu überdenken. Das habe ich gemacht. Intuitiv war anstatt bis n (gesuchte Zahl) zu summieren bis n+(n-1) = 2n-1. Und die Summe durch n zu teilen. Der N = 2n-1 ist allgemein für gerade Zahlen. Und die Summe aller k von 1..2n-1 geteilt durch 2n-1 ist = n, was unsere zu zerlegende Zahl ist.  QED. #

Ein vierter Fall ist oben auch angesprochen. Beliebige (skalierbare) Anzahl monoton wachsender Brüche 1/N,...,n/N,n+1/N,n+2/N,...,n+m/N um die Zahl zu zerlegen. Eine 1 kann man ohne Sorge in n(n+1)/2 Brüche zerlegen mit dem Nenner n(n+1)/2.Die Folge ist (k/[n(n+1)/2])k=1...n. Die Reihe ihre Summe und gleich der zu zerlegenden Zahl.  Bei ungeraden Zahlen, da hat man den Nenner N=(n+1)/2, da man noch durch n (die zu zerlegende Zahl) teilen muss, damit die Summanden ein n-faches des vollen Zählers zum Nenner ergeben. Also der skalierbare Fall 4, vergroesserbare Anzahl der Summanden (also der Brüche), wie bei der Zerlegung der 1 ganz direkt möglich (indem man einfach ein n wählt), kommt morgen nochmal dran.

Mein erstes Papier dazu berücksichtigt die geraden Zahlen noch nicht, das kam erst durch das Setzen. Jetzt muss ich das nochmal formulieren, hehe.

Was übrigens auffällt. Der letzte Summand ist 2n-1/2n-1  = 1. Die letzte Zahl in der Reihe, das schwerste Gewicht, ist gleich 1/1.

 

Update 2: Zusammenfassend ist die Zerlegung der Eins das sinnvollste, der Einsatz als Gewicht (z.B. Masse) einzelner Glieder ist auf die genaue Anzahl der Glieder abstimmbar. Man kann auch zehn Zehntel nehmen und die individuell auf n <= 10 Zahlen verteilen. Die nicht mehr einwandfreie Skalierbarkeit bei einer geraden Zahl, macht den Erfolg bei ungeraden Zahlen ganzzahlige Nenner wie (n+1)/2 zu erhalten, der übrigens noch kleiner Z ist (d.h. mehr als ein Bruch ist unecht/gemischt und groesser als 1/1), beinah kaputt, da die Zerlegung unbrauchbar wäre, wäre da nicht der Kompromiss 2k/2N zu summieren, ist die Zahl gerade. Darum ist meine Empfehlung die Eins, in n Brüche zerlegt, als Faktor zu nehmen, vielleicht diese noch zu skalieren.

Eine Anwendung auf die 'GM-AM Ungleichung mit gebrochenen Gewichten' mit [(Summe k=1,n p_k)  = 1] bringt übrigens Erfolg. Sie wird von [(Produkt k=1,n a_k^p_k) <= (Summe k=1,n p_k*a_k)] zu [(Produkt k=1,n a_k^k)^1/N <= 1/N(Summe k=1,n k*a_k)].

Eine Fortsetzung der Idee ist, zum Beispiel nichtlineare Zaehler k^2, k^3 und ihre Summen (2n+1)(n+1)n/6 und (n(n+1)/2)^2 einzusetzen. Und weitere Formeln mit Gewichten auszuprobieren. Ebenso Ungleichungen mit konjugierten Exponenten. Und verwandtes.

 

Limespaper

root (Edward Gerhold)

Ich hab noch was besseres, worauf sich viele freuen werden, das mal durch zu nehmen. "How to calculate limits". In dem Paper berechne ich Differentialquotienten, Integrale, Folgen, Reihen in Grenzwertform. Gestern habe ich damit begonnen und bislang Potenzregel, Produktregel, Quotientenregel und Kettenregel ausgerechnet und gesetzt, aber das geht natürlich weiter. Und wenn ich genug Beispiele gerechnet und Tricks vorgestellt habe, dann poste ich es auch. Und wie ich gesehen habe, kann man diese Dinge im Internet sogar sharen. Mein Koordinatensystem wird auch irgendwann neu verfasst sein, wie angekündigt. Bis dahin, viel Spass beim selbst rechnen, weil´s Spass macht :-)

Update:

Limes von Funktionen. Algebraisch umformen, wie in der Schule, daß man z.B. bei x->0 (x gegen 0) dafür sorgt, daß die 0 nicht im Nenner allein steht. Bei 0/0 oder infty/infty mit L´Hopital und dem Limes der Ableitungen probieren.

Limes von Ableitungen per Differentialquotient. Dafür sorgen, daß man h/h erhält und kürzen kann, oder Summanden auf dem gleichen Hauptnenner trennen, um einzelne Brüche gegen 0 im Zähler laufen zu lassen. Alles ist erlaubt, Ausklammern, Vereinfachen, Erweitern, neu Zusammenfassen, wieder ausmultiplizieren. Bis man die günstigste Form erhält, um den DQ gegen 0 gehen zu lassen. Die Terme die bleiben sind die Ableitung. Kann sein, daß sich das von der generalisierten Ableitung unterscheidet, daß man die einzelnen Teile wie f'(g(x))*g'(x) nicht mehr erkennt, und alles eine Form ergibt wie 2a^2x statt 2ax * a für f(x)=x^2 und g(x)=a.

Limes von Integralen. n-> unendlich. Man schreibt die endliche Summe hinter den Limes von i=1 bis n und rechnet f(x_j)*delta_X_j mit x_j = a+(j-1)delta_X_j und delta_X_j = delta_X = (b-a)/n. Dann rechnet man die Summe nach und nach aus. Durch ausmultiplizieren und aufteilen in einzelne Teile, kann man die einzelnen Summen durch bekannte und geschlossene Formen ersetzen. Zum Beispiel ist die Summe von allen i auch als Gaussformel bekannt und ergibt n(n+1)/2. Die Summe von (i-1) ergibt n(n-1)/2, was man rauskriegt, wenn man in n(n+1)/2 dann (n-1)((n-1)+1)/2 einsetzt und vereinfacht.

Limes von Folgen. Man schreibt die Folge hinter das limes gegen unendlich und vereinfacht die Formel algebraisch solange, bis man sie sicher gegen unendlich schicken kann. Wenn die divergiert kommt eh unendlich raus, ist klar. Und für konvergente Folgen, oder lim = 0 (Nullfolge) sollte man Brüche auf Brüchen finden, z.B. (1+1/n)/2 ist wenn n->unendlich dann 1+0/2 = 1/2.

-Geht n gegen 0, sollte man die 0 im Nenner vermeiden, da null kein Teiler ist.

-Geht n gegen unendlich, sollte man die unendlich in den Nenner bringen, weil der Bruch dann 0 wird (1/infty = 0, aber auch (1/infty)/10 = 0). Man sollte versuchen alles voneinander zu isolieren, um Zahlen zu behalten.

Grenzwert von Reihen. Wie bei den Integralen schreibt man die Summe hin und zieht alle Konstanten aus der Sigma-Form und versucht die verbleibenden Glieder durch einfache Summen zu ersetzen. Viele Reihen kann man nicht richtig ausrechnen und nur abschätzen, wofür es die bekannten Konvergenzkriterien gibt. Damit kann man die Glieder vergleichen, oder auch schauen, ob man unter bekannten konvergenten Reihen liegt, oder über divergenten Reihen. Reihen sind schwierig in geschlossene Form zu bringen.

Limes von Integralen. Integrale bringen dann lange Polynome, die man ausmultiplizieren und zusammenfassen muss. Bei Integralen, die man aufleiten kann, sollte nach Zusammenfassen der Terme die bekannte Formel stehen bleiben. Für delta X (b-a)/n ist der Binomialkoeffizient wichtig, da man bereits beim Integral von alpha*x = alpha*Integral von x ((b-a)n)^2 findet und sich das natürlich vermehrt. Die werden richtig haarig, was man der generalisierten Form des Aufleitens nicht ansieht.

Limes von Riemann-Stieltjes (t)dg(t), man multipliziert f(t) nicht mit (b-a)/n (delta t), sondern mit (g(t_i)-g(t_i-1)) und nimmt der Grenzwert der gesamten Formel. Natürlich wird das noch haariger, als nach dx, nach dg(x), weil noch mehr Formel einfliesst.  Limes von Funktionenfolgen ist mit Folgenlimes bereits klar. Die korrekte Neuformulierung meines Wissens über L^p Konvergenz und das Lebesguesche Integral ist ein der nächsten Aufgaben für mich. t_i ist jetzt natürlich auch a+(t-1)(b-a)/n sofern [a,b] der Integrationsbereich ist.

Ich habe da also zwei Hauptmethoden ausgemacht, beim Integral das Herausziehen von allen Konstanten ausser dem Zähler der Summe. Der wird z.B. bei Summe (i-1) mit n(n-1) ersetzt, usw. Wenn alle Glieder sicher gegen unendlich gehen können, also am besten das n im Nenner ist, da x/unendlich = null ist, und wir damit nur ein n und dessen Term streichen können. Und die andere ist, beim Differentialquotienten muss man die 0 aus dem Nenner rauskriegen, also das n oder h in denn Zähler bringen oder die Terme so spalten, daß nicht gleich alles gegen null geht.

Fakt ist, alles, Ausmultiplizieren, Erweitern, Kürzen, Vereinfachen, Zusammenfassen, mit Identischen Formen anderer Art ersetzen (1 mit sin^2 x+cos^2 x z.B.), all das hilft, die Polstellen und Undefinierte zu eliminieren. Ist aber keine Garantie, daß das geht. Denn es gibt genug divergente Reihen, deren Limes unendlich ist, genug Funktionen und Folgen, die hier und da nicht differenziert werden, oder keine Nullfolge sind. Es ist halt wichtig, zu wissen, wann das der Fall ist.

All das steht so nicht im Paper. Aber ich hatte hier diesen Artikel kommentiert, und das ist eine schnelle Neufassung meines Kommentars. Viel Vergnügen beim selbst lösen.

Deutsche Version

root (Edward Gerhold)

Deutsche Version kurz mit ein paar Passagen upgedatet.

Vektorwertiges Skalarprodukt

root (Edward Gerhold)

Aufgrund meiner Formel für eine lineare Abbildung auf eine Fläche mit drei Koordinaten, lag es nahe, zu versuchen, ein vektorwertiges Skalarprodukt zu definieren, was den R^3 Vektor mit einem (R^2)^3 (=R^2x3) zu multiplizieren und die Komponentenprodukte zu summieren. Das Problem ist, man muss einen Vektor aus den ersten Komponenten der mehreren Vektoren, die man gleichzeitig dotten will, machen, einen aus den zweiten, einen aus den dritten, usw. Die 2x3 Matrix erledigt das auf natürliche Weise, indem die Vektoren zu Zeilenvektoren werden. Damit war die Definition dann an der Unbequemlichkeit, die Vektoren aufzuspalten und per Komponentenindex zu gruppieren, gescheitert, mit Vermerk, dass auf natürliche Weise das Matrixprodukt exakt die Aufgabe erledigt. Eine vollständige Beschreibung des Vorgangs im neuen Dokument, für das ich das definieren wollte. So habe ich allerdings auch eine vernünftige Erklärung zu meinem Fund.

SVD bei Wolfram

root (Edward Gerhold)

Ich hatte bereits geahnt, daß die trigonometrische Version mit drei Achsen aufwändig zu berechnen ist. Wolfram Alpha zeigt, die SVD passt nicht mehr auf eine Seite.

https://www.wolframalpha.com/input/?i=SVD+{{cos%28a%29%2Ccos%28b%29%2Ccos%28c%29}%2C{sin%28a%29%2Csin%28b%29%2Csin%28c%29}}

Etwas einfacher sind die links- und rechtshändigen Koordinatensysteme mit 45 bzw. 225 Grad Achse eingebettet in der orthonormalen R^2 Basis.

https://www.wolframalpha.com/input/?i=SVD+{{1%2C0%2Csqrt%280.5%29}%2C{0%2C1%2Csqrt%280.5%29}} ist die LHS Basis mit z auf 45 Grad, x auf 0 und y auf 90 Grad.

https://www.wolframalpha.com/input/?i=SVD+{{-sqrt%280.5%29%2C1%2C0}%2C{-sqrt%280.5%29%2C0%2C1}} ist die RHS Basis mit x auf 225 Grad und y 0 und z 90 Grad.

Sphäre zeichnen

root (Edward Gerhold)

Abb 1. Eine Sphäre mit createSphere erzeugt und nach transform2dAll von Punkt zu Punkt, Ring für Ring verbunden. Das sind jeweils Ringe aus einfachen Kreisen entlang jeder Achse, den Radius erhält man mit Sinus auf der Achskoordinate welche ein Kosinus wäre.

Ich hatte noch nicht ausprobiert, eine Kugel aus Ringen zu zeichnen. Um die Abbildung auf 2-D Koordinaten vorzunehmen, habe ich die 3-D Koordinaten mit meiner Gerhold-Formel umgewandelt. Die Summe, aus den drei Produkten je einer Koordinate mit je einem 2-D Achsvektor, ergibt einen neuen 2-D Ortsvektor, den richtigen Punkt im, durch ausrichten der drei Achsen gewählten, 3-D Koordinatensystem auf der Fläche, wörtlich Σxiei, wobei x ein R^3 Vektor und e ein Vektor aus drei R^2 Vektoren ist.

Mir kam die Idee, daß ich das und andere geometrischen Modelle alle noch nicht vorgestellt habe. Inzwischen habe ich mir ein paar Gedanken dazu gemacht, denn ich habe das Dokument, was ich vier Wochen entusiastisch entwarf und entwickelte als veraltet deklariert. Aber nicht, um es aufzugeben. Das neue Dokument ist kürzer, prägnanter, die zu angefangenen oder zu korrigierenden Rechnungen werde ich vorlegen, und am Schwierigkeitsgrad werde ich auch was gedreht haben. Es wird sehr interessant, denn ich definiere die Fläche mit den drei Koordinaten. Die R^2x3 Ebene. Ich finde, man kann leicht glauben, daß die lineare Algebra das alles abdeckt.Das Koordinatensystem passt zwar in die Spalten der 2x3 Matrix und bietet eine surjektive, nicht invertierbare lineare Abbildung von 3-D auf 2-D. Allerdings ist es nicht so geläufig. Und ich habe Ableitungen und Integrale einer linearen Funktion entwickelt, welche exakt die selbe lineare Abbildung vornehmen. Ich hatte mir vor einer Weile Grundlagen in Vektoranalysis angeeignet und konnte diese hier prima ausnutzen, um die Funktion zu erforschen. Die Funktion stelle ich ebenso vor wie einige Alternativen, Schlussfolgerungen sowie eine Verallgemeinerung bestimmter linearer Abbildungen.

Abb. 2 Die Sphäre mit Kugelkoordinaten erzeugt und einmal den ersten Winkel festgehalten und einmal den zweiten Winkel, um die einzelnen Ringe einmal zu durchlaufen. Es ist wohl nicht der richtige Algorithmus. Sphären in Matheskripten sehen anders aus. Nächstesmal dann.

 

Wer richtig hinschaut kann am unteren Bildbereich sehen, daß mit den Kugelkoordinaten ein Fehler auftritt. Sollte ich x,y,z tauschen, sieht man keinen Fehler. Allerdings sonst keinen grossartigen Unterschied. Man kriegt durch bewegen des Nordpols nach oben nicht den Sphärenflair aus den Abbildungen aus Mathebüchern mit. Hier ist vielleicht der Algorithmus falsch.

Die Fläche mit den drei Koordinaten hat eine Basis, die am Kreis ausgerichtet wird. Es sind drei Achsen. Drei einheitslange Ortsvektoren die am Kreis ausgerichtet werden. Eine Basis ist linear unabhängig? Ich sage, die Linearkombination bleibt. Für die Fläche mit den drei Koordinaten ist die Achse unverzichtbar. Die lineare Abbildung, die mit den drei Achsen entsteht, ist eine korrekte orthogonale Projektion, kompakt und stetig.

Eine Schreibweise mit drei Koordinaten ist auch möglich. Durch Einsatz der gewohnten xi+yj+zk Notation, kann man, wobei i,j,k nun 2-D Vektoren sind, die Summe mit drei Koordinaten in ihrer Grundform darstellen. Das Ergebnis der Summe ist ein 2-D Punkt, in Vektorschreibweise, dadurch, daß anstelle der 3x3 Basis eine 2x3 Basis eingesetzt wurde. Das ist ein fantastisches Werkzeug in Verbindung mit Funktionen, welche diese Notation nutzen, finde ich.

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.

[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 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 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 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 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