Input/Output Wie schreibt man programmatisch Matrizen auf?

[horstiii1]

    public static void main(String[] args) {
        System.out.println(new Matrix(2, 3, "a","a","b","b","c","c" ).toString());
    }

public class Matrix {
    int n_spalten;
    int m_zeilen;
    String[][] a;

    public Matrix(int n_spalten, int m_zeilen, String... v) {
        this.n_spalten = n_spalten;
        this.m_zeilen = m_zeilen;
        this.a = new String[m_zeilen][n_spalten];
        for (int i = 0; i < v.length; i++) {
            a[i / n_spalten][i % n_spalten] = v[i];
        }
    }

    @Override
    public String toString() {
        return m_zeilen + "x" + n_spalten + "[" + Arrays.stream(a).map((t) -> {
            return "[" + Arrays.stream(t).collect(Collectors.joining(",")) + "]";
        }).collect(Collectors.joining(", ")) + "]";
    }
}

Ergebnis:

3x2[[a,a], [b,b], [c,c]]

Ist das richtig??

 

[MoxxiManagarm]

Sieht erstmal nicht verkehrt aus. Ist das von dir oder verstehst du es einfach nicht?

 

[horstiii1]

Ist das von dir

ja

verstehst du es einfach nicht

ja

Aber kannst Du mir helfen?

 

[MoxxiManagarm]

Wie schaffst du es etwas zu schreiben was du nicht verstehst ^^
Wobei soll ich dir denn helfen? Es scheint doch zu funktionieren ^^
Oder gibt es noch ein Problem?

 

[horstiii1]

Wann können zwei Matrizen multipliziert werden, wann addiert und wann kann eine Addition nicht durch Multiplikation ersetzt werden - und können Matrizen anstelle einer Subtraktion durch Addition mit einem Entgegengesetztem immer addiert werden ? Sorry aber das verwirrt mich

 

[MoxxiManagarm]

Das ist eine mathematische Frage, die du durch etwas googlen beantwortet bekommst.

 

[horstiii1]

danke, ich hab mir alles durchgelesen. Geht das und wie nennt es sich (das subAdd ):

    public static void main(String[] args) {
        System.out.println("Nullmatrix, " + Matrix.getNullmatrix(4, 4));
        System.out.println("Einsmatrix, " + Matrix.getEinsmatrix(4, 4));
        System.out.println("Einheitsmatrix, " + Matrix.getEinheitsmatrix(4, 4));
        System.out.println();
        Matrix a = Matrix.getEinsmatrix(3, 3).add(Matrix.getEinheitsmatrix(3, 3)).add(Matrix.getNullmatrix(3, 3));
        Matrix b = Matrix.getNullmatrix(3, 3).subAdd(Matrix.getEinheitsmatrix(3, 3)).subAdd(Matrix.getEinsmatrix(3, 3));
        System.out.println(a + "\n=\n" + a.calculate());
        System.out.println();
        System.out.println(b + "\n=\n" + b.calculate());
    }

...

Nullmatrix, 4x4[[0,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0]]
Einsmatrix, 4x4[[1,1,1,1], [1,1,1,1], [1,1,1,1], [1,1,1,1]]
Einheitsmatrix, 4x4[[1,0,0,0], [0,1,0,0], [0,0,1,0], [0,0,0,1]]

3x3[[1+1+0,1+0+0,1+0+0], [1+0+0,1+1+0,1+0+0], [1+0+0,1+0+0,1+1+0]]
=
3x3[[2.0,1.0,1.0], [1.0,2.0,1.0], [1.0,1.0,2.0]]

3x3[[(-(1)+(-(1)+0)),(-(1)+(-(0)+0)),(-(1)+(-(0)+0))], [(-(1)+(-(0)+0)),(-(1)+(-(1)+0)),(-(1)+(-(0)+0))], [(-(1)+(-(0)+0)),(-(1)+(-(0)+0)),(-(1)+(-(1)+0))]]
=
3x3[[-2.0,-1.0,-1.0], [-1.0,-2.0,-1.0], [-1.0,-1.0,-2.0]]

 

[mihe7]

wie nennt es sich (das subAdd ):

Subtraktion?

 

[MoxxiManagarm]

Meinst du die Verkettung?

Matrix.getEinsmatrix(3, 3).add(Matrix.getEinheitsmatrix(3, 3)).add(Matrix.getNullmatrix(3, 3));

Das ist letztlich ein Builder Pattern. Beispiel StringBuilder:

StringBuilder sb = new StringBuilder("Initialwert"); // Matrix x = Matrix.getEinsmatrix(3.3)
s.append("foo"); // m.add(Matrix.getEinheitsmatrix(3, 3))
s.append("bar"); // m.add(Matrix.getEinheitsmatrix(3, 3))
String s = sb.toString(); //m.calculate();

Wobei man sich über die Benamung streiten könnte wie ich finde, denn ein MatrixBuilder, hier ein MatrixAddierer, ist nunmal keine Matrix, sondern hält intern eine Menge von matrizen und produziert eine.

 

[horstiii1]

Subtraktion?

Subtraktion durch Addition?

@ Moxxi ja es ist das fluent interface pattern

 

[MoxxiManagarm]

@ Moxxi ja es ist das fluent interface pattern

Da würde ich dir nur zustimmen wenn add() tatsächlich addieren würde. Du hast aber noch den build Schritt und zuvor nur die Ansammlung von Argumenten. Aber diese Diskussion ist eher eine Kleinigkeit, du hast ein funktionierendes stimmiges pattern.

Aber deine Fragen sind in der Gesamtheit immer noch nicht klar, was willst du wissen? Möchtest du nur eine Bestätigung, dass dein Code funktioniert? Diese solltest du nicht bei uns suchen. Hab ein wenig Selbstvertrauen in dein Produkt, andernfalls bekommt man leicht das Gefühl, dass es nicht deins ist. Darüber hinaus gibt es Junit tests, die dir wiederholt diese Bestätigung liefern können.

 

[mihe7]

Subtraktion durch Addition?

Dir geht's um die Unterscheidung wg. der Darstellung? Vielleicht kann man -M als negative Matrix bezeichnen: addNeg(M)==add(neg(M))

 

[mrBrown]

Da würde ich dir nur zustimmen wenn add() tatsächlich addieren würde. Du hast aber noch den build Schritt und zuvor nur die Ansammlung von Argumenten. Aber diese Diskussion ist eher eine Kleinigkeit, du hast ein funktionierendes stimmiges pattern.

add addiert doch wirklich und es gibt keinen Build-Schritt, oder missversteh ich das grad völlig?
Es gibt doch auch keinen Builder (oder Addierer)

 

[MoxxiManagarm]

add addiert doch wirklich und es gibt keinen Build-Schritt, oder missversteh ich das grad völlig?
Es gibt doch auch keinen Builder (oder Addierer)

Nein, das addiert nach seiner Angabe noch nicht. Dieser Code

Matrix a = Matrix.getEinsmatrix(3, 3).add(Matrix.getEinheitsmatrix(3, 3)).add(Matrix.getNullmatrix(3, 3));
System.out.println(a + "\n=\n" + a.calculate());

bringt diese Ausgabe:

3x3[[1+1+0,1+0+0,1+0+0], [1+0+0,1+1+0,1+0+0], [1+0+0,1+0+0,1+1+0]]
=
3x3[[2.0,1.0,1.0], [1.0,2.0,1.0], [1.0,1.0,2.0]]

Die Matrix a hält also noch alle Summanten vor und gibt das Ergebnis nur mit a.calculate() in der letzten Zeile aus. a.calculate() ist an der Stelle ein build()-ähnlicher Aufruf

 

[mrBrown]

Oh, ganz überlesen -.-

Ist ja grausam...

 

[MoxxiManagarm]

Ist ja grausam...

Ja eben, ich würde eine Matrix und einen MatrixBuilder (wie man auch immer den dann nennen mag) persönlich strikt trennen und für diese Art der Berechnung einen genau solchen Builder erstellen - ihn dann MatrixBuilder, MatrixAddierer oder wie auch immer nennen. So wie es jetzt gerade ist, ist es eher eine Matrix, welche optional auch ein Builder ist.

 

[horstiii1]

Guten abend,

So wie es jetzt gerade ist, ist es eher eine Matrix, welche optional auch ein Builder ist

Ja aber das darf man doch mixen?

Oder sei dann die logische Einheit verletzt?

    static Matrix getEinsmatrix(int n_spalten, int m_zeilen) {
        String[] v = new String[n_spalten * m_zeilen];
        Arrays.fill(v, "1");
        return new Matrix(n_spalten, m_zeilen, v);
    }

    Matrix add(Matrix b) {
        Matrix c = new Matrix(n_spalten, m_zeilen, new String[n_spalten * m_zeilen]);
        for (int i = 0; i < m_zeilen; i++) {
            for (int j = 0; j < n_spalten; j++) {
                c.val[i][j] = val[i][j] + "+" + b.val[i][j];
            }
        }
        return c;
    }

    Matrix sub(Matrix b) {
        Matrix c = new Matrix(n_spalten, m_zeilen, new String[n_spalten * m_zeilen]);
        for (int i = 0; i < m_zeilen; i++) {
            for (int j = 0; j < n_spalten; j++) {
                c.val[i][j] = val[i][j] + "-" + b.val[i][j];
            }
        }
        return c;
    }

    Matrix subAdd(Matrix b) {
        Matrix c = new Matrix(n_spalten, m_zeilen, new String[n_spalten * m_zeilen]);
        for (int i = 0; i < m_zeilen; i++) {
            for (int j = 0; j < n_spalten; j++) {
                c.val[i][j] = "(-(" + b.val[i][j] + ")+" + val[i][j] + ")";
            }
        }
        return c;
    }

    Matrix calculate() {
        Matrix c = new Matrix(n_spalten, m_zeilen, new String[n_spalten * m_zeilen]);
        for (int i = 0; i < m_zeilen; i++) {
            for (int j = 0; j < n_spalten; j++) {
                c.val[i][j] = // magic
            }
        }
        return c;
    }

    @Override
    public String toString() {
        return m_zeilen + "x" + n_spalten + "[" + Arrays.stream(val).map((t) -> {
            return "[" + Arrays.stream(t).collect(Collectors.joining(",")) + "]";
        }).collect(Collectors.joining(", ")) + "]";
    }

Ich denke die Designentscheidung sei richtig. Aber auch mathematisch sinnvoll?

Was @mrBrown geschrieben hat kommt mir spanisch vor.

 

[httpdigest]

Aber auch mathematisch sinnvoll?

Kommt auf deine Definition von "sinnvoll" an. Ich persönlich finde hieran überhaupt nichts sinnvoll. Was für einen Anwendungsfall willst du denn mit dem Ganzen überhaupt unterstützen? Wann und wofür sollte jemand denn ein String-Array mit aneinanderkonkatenierten Operationen haben wollen?

 

[horstiii1]

Wann und wofür sollte jemand denn ein String-Array mit aneinanderkonkatenierten Operationen haben wollen

Kann mich nicht entsinnen dass ich etwas von jemand andres geschrieben habe...

 

[MoxxiManagarm]

Dürfen tust du es natürlich schon. Aber es ist doch für andere einfach irritierend, genauso wie Mr Brown es überlesen hatte - er hatte schlichtweg nicht damit gerechnet. In der beruflichen Programmierwelt versucht man immer Entities (Module) und die Logik (Services) voneinander zu trennen. Es soll eigentlich nur ein Rat sein, auch wenn es uns manchmal schwer fällt es als solchen darzustellen. Bevor du calculate() aufrufst ist deine Matrix eben keine Matrix, sondern ein algebraisches Mittel. Zusätzlich fügst du alles zu Strings nur um diese später wieder zu parsen (mit magic). Ich hatte ja erwartet, dass Matrix intern eine Liste von gleichgroßen Matrizen hält.

 

[httpdigest]

Kann mich nicht entsinnen dass ich etwas von jemand andres geschrieben habe...

Ich ebensowenig.
Sorry, wollte nicht böse klingen. Aber es ist vielleicht für alle besser zu verstehen, was du denn eigentlich machen willst und was dein Ziel ist. Dein initialer Post hat ja nur Code gezeigt und gefragt, ob das so richtig ist. Richtig wofür?

 

[horstiii1]

Danke dir @httpdigest meins sollte ja auch nicht bös gemeint sein...

Ich weiß noch nicht genau was es tun soll.