matrici bidimensionali vari problemi

[Cracker1992]

ho un po' domande da rispondere teoricamnte e come codici che è un argomento che non ben capito se dareste una mano.
1) come definisco se una matrice è simmetrica
2) come definisco gli elementi contenuti nella diagonale principale
so che sono gli elementi con stesso indice riga e stesso indice colonna ma non so come esprimerlo con un metodo.
l'if lo so ma non so come definire quanti valori ci sono in una matrice pu che altro come farlo generale il codice.
3)come faccio vedere se è indentita un matrice
4) come faccio a scrivere che è triangolare superiore o inferiore più che altro come faccio a vedere se gli elementi sono sopra o sotto la diagonale .
5) una matrice inversa come definirla e matrice diagonale
6) la somma come si fa?
sopratutto dei codici commentati anche senza tanta spiega.

[VincenzoTheBest]

Originariamente inviato da Cracker1992
ho un po' domande da rispondere teoricamnte e come codici che è un argomento che non ben capito se dareste una mano.
1) come definisco se una matrice è simmetrica
2) come definisco gli elementi contenuti nella diagonale principale
so che sono gli elementi con stesso indice riga e stesso indice colonna ma non so come esprimerlo con un metodo.
l'if lo so ma non so come definire quanti valori ci sono in una matrice pu che altro come farlo generale il codice.
3)come faccio vedere se è indentita un matrice
4) come faccio a scrivere che è triangololare superiore o inferiore più che altro come faccio a vedere se gli elementi sono sopra o sotto la diagonale .
5) una matrice inversa come definirla
6) la somma come si fa?
sopratutto dei codici commentati anche senza tanta spiega.

Sai come rappresentare una matrice in java?
Posta un pò di codice. Non credo tu riesca a trovare qualcuno che ha intenzione di fare i compiti a casa per terze persone.

[Cracker1992]

non sono compiti ma devo preparare una verifica e comunque volevo una spiegazione non proprio codice già fatti. comunque qui sotto posto la classe matrice. tanti codici non rispecchiano la teoria ma sono messi per mia invenzione per vedere se funzionavano e forse il ragionamento e abbastanza sbagliato perchè non le capite.

package matrici;

public class matrice {

    int righe, colonne;
    int[][] valore;
    static final int DIMR = 50;
    static final int DIMC = 50;

    public matrice(int righe, int colonne) {
        this.colonne = colonne;
        this.righe = righe;
        this.valore = new int[DIMC][DIMR];
    }

    public int getColonne() {
        return colonne;
    }

    public void setColonne(int colonne) {
        this.colonne = colonne;
    }

    public int getRighe() {
        return righe;
    }

    public void setRighe(int righe) {
        this.righe = righe;
    }

    public String isQuadrata() {
        if (righe != colonne) {
            return "matrice rettangolare";
        } else {
            return "matrice quadrata";
        }
    }

    public void setValore(int val) {
        valore[righe][colonne] = val;
    }

    public int getValore() {
        return valore[righe][colonne];
    }

    public String isTrasposta() {
        if (valore[righe][colonne] == valore[colonne][righe]) {
            return "matrice trasposta";
        } else {
            return "matrice non trasposta";
        }
    }

    public String isNulla() {
        if (valore[righe][colonne] == 0) {
            return "matrice nulla";

        } else {
            return "matrice non nulla";
        }
    }

    public void getSomma(matrice m) {
        if (this.righe == m.righe && this.colonne == m.colonne) {
            for (int i = 0; i < righe; i++) {
                for (int j = 0; j < righe; j++) {
                    int risultato = i + j;
                }
            }
        } else {
            System.err.println("non si puo sommare");
        }
    }

    public String isDiagonale() {
        if (valore[righe][colonne] == 0 && valore[righe++][1] != 0) {
            return "matrice diagonale";
        } else {
            return "matrice non diagonale";
        }
    }

    public String isSimmetrica() {
        if (valore[righe][colonne] == valore[righe++][1]) {
            return "matrice simmetrica";
        } else {
            return "matrice non simmetrica";
        }
    }

    public String isIndentita() {
        if (valore[righe++][1] == 1) {
            return "matrice indentita";
        } else {
            return "matrice non indentitat";
        }
    }

    public String istriangolareSuperiore() {
        String s="";
        for (int i = 0; i < righe; i++) {
            i += righe++;
            if (valore[righe++][i] == 0) {
           s+="matrice triangolare superiore";
        } else {
            for (int j = 0; j > colonne; j++) {
                j += colonne++;
                if (valore[righe++][j] == 0) {
                    s+="matrice triangolare inferiore";
                } else {
                   s+= "matrice triangolare non superiore ma neanche inferiore";

                }
            }

        }
        }
        return s;

    }
}

anzi sono quasi senza senso però boh son in confusione totale. calcolando che ancora nel java e nella programmazione alle prime armi. in ogni caso vorrei un metodo unico per le triangolari secondo me si può fare e viene più carino anche se è più complesso farlo piuttosto che due metodi.

[VincenzoTheBest]

Originariamente inviato da Cracker1992
anzi sono quasi senza senso però boh son in confusione totale. calcolando che ancora nel java e nella programmazione alle prime armi. in ogni caso vorrei un metodo unico per le triangolari secondo me si può fare e viene più carino anche se è più complesso farlo piuttosto che due metodi.

Visto che sei alle prime armi, ti conviene farne due distinti.
Ho dato un'occhiata alle implementazioni dei metodi...a parte isQuadrata, il resto non ha senso.

[Cracker1992]

bene almeno un metodo ha senso perlomeno sono un passo avanti, comunque un altra volta posto la mai classe matrice rifatta a scuola che ora non posso postare ora e questa volta tutto ha senso e ho risolto quasi tutto tranne se è triangolare superiore o inferiore che non so come dire se gli indici sono sopra o sotto alla diagonale. comunque per quanto riguarda a questa classe matrice is trasposta, is nulla hanno un senso.

[Cracker1992]

questa è la classe matrice rifatta:

package matrici;

public class matrice {

    int righe, colonne;
    int[][] valori;
    static final int DIMR = 50;
    static final int DIMC = 50;

    public matrice(int righe, int colonne) {
        this.colonne = colonne;
        this.righe = righe;
        this.valori = new int[DIMC][DIMR];
    }

    public int getColonne() {
        return colonne;
    }

    public int getRighe() {
        return righe;
    }

    public String isQuadrata() {
        if (this.valori[righe] != this.valori[colonne]) {
            return "matrice rettangolare";
        } else {
            return "matrice quadrata";
        }
    }

    public void setValore(int val, int righe, int colonne) {
        valori[righe][colonne] = val;
    }

    public int getValore(int righe, int colonne) {
        return valori[righe][colonne];
    }

    public String isTrasposta() {
        if (this.valori[righe][colonne] == this.valori[colonne][righe]) {
            return "matrice trasposta";
        } else {
            return "matrice non trasposta";
        }
    }

    public String isNulla() {
        if (this.valori[righe][colonne] == 0) {
            return "matrice nulla";
        } else {
            return "matrice non nulla";
        }
    }

    public void getSomma(matrice m) {
        if (this.valori[righe] == m.valori[righe] && this.valori[colonne] == m.valori[colonne]) {
            for (int i = 0; i < righe; i++) {
                for (int j = 0; j < colonne; j++) {
                    this.valori[i][j] += m.valori[i][j];
                }
            }
        } else {
            System.err.println("non si puo sommare");
        }
    }

    public String isInversa() {
        if ((this.valori[righe][colonne]) * ((this.valori[righe][colonne]) - 1) == 1) {
            return "matrice inversa";
        } else {
            return "matrice non inversa";
        }
    }

    public String isSimmetrica() {
        if (isTrasposta().equalsIgnoreCase("matrice trasposta")) {
            return "matrice simmetrica";
        } else {
            return "matrice non simmetrica";
        }
    }

    public String isIndentita() {
        if (this.valori[righe] == this.valori[colonne] && this.valori[righe][colonne] == 1) {
            return "matrice indentita";
        } else {
            return "matrice  non indentita";
        }
    }

    public String isDiagonale() {
        if (this.valori[righe] == this.valori[colonne] && this.valori[righe][colonne] == 0) {
            return "matrice diagonale";
        } else {
            return "matrice  non diagonale";
        }
    }

    public String istriangolareSuperiore() {
        String s="";
        if (this.valori[righe] != this.valori[colonne]) {
            for (int i = 1; i < righe; i++) {
                for (int j = 1; j < righe; j++) {
                    if (this.valori[righe][colonne] == this.valori[i][j]) {
                        s = "matrice triangolare inferiore";
                    } else {
                        for (int k = 1; k < righe; k--) {
                            for (int l = 1; l < righe; l--) {
                                if (this.valori[righe][colonne] == this.valori[k][l]) {
                                    s = "matrice triangolare superiore";
                                } else {
                                    s = "matrice non triangolare";
                                }
                               
                            }
                        }
                    }
                }
            }
        } else {
            System.err.println("ci troviamo nella diagolnale");
        }
         return s;
    }
}

[VincenzoTheBest]

A parte il metodo getSomma ed i metodi get e set, il resto è sbagliato (per logica e definizione).
Cerca di rivedere bene il tutto.

[Cracker1992]

e cosa dovrei correggere come metto le condizioni giuste sopratutto come guardo se un valore della matrice è nella diagonale o no.
perchè su excell lo vedo subito ma su netbeans non so esprimerlo.
ma anche il costruttore, e le proprietà dici che sono sbagliate?
e i metodi tipo is quadrata, is nulla, is inversa, is trasposta mi sembrano giusti il procedimento poi is in un metodo string non è giusto lo so che non so come chiamarli questi metodi e per non farli booleani.
se sbaglio anche le definizioni dove le trovo?

[VincenzoTheBest]

Originariamente inviato da Cracker1992
ma anche il costruttore, e le proprietà dici che sono sbagliate?

Nel costruttore, la proprietà valori devi inizializzarla con le proprietà colonne e righe; le due costanti DIMR e DIMC non servono.

Originariamente inviato da Cracker1992
i metodi tipo is quadrata, is nulla, is inversa, is trasposta mi sembrano giusti il procedimento poi is in un metodo string non è giusto lo so che non so come chiamarli questi metodi e per non farli booleani.

Purtroppo non lo sono affatto, in quanto alcuni metodi devono avere una segnatura/definizione diversa ed inoltre devono rispettare la parte logica/teorica delle matrici che vogliono implementare.
Ad esempio il metodo per verificare se una matrice è la trasposta di un'altra (logica a parte) andrebbe definito in questo modo:

public boolean isTraspostaOf(Matrice m){
   //logica...
}

[bstefano79]

Originariamente inviato da VincenzoTheBest
a parte isQuadrata, il resto non ha senso.

un metodo isNomeMetodo che torna una stringa non lo avevo ancora visto