A
anfaenger
Gast
Hi!
Ich hatte die Aufgabe, zu sagen, ob eine Funktion eine Relation darstellt oder nicht (ich glaube, wie das funktioniert ist bei meinem Problem eigentlich unwichtig, weil ich denke, ich habe das inhaltlich ganz gut hinbekommen), jetzt meckert nur mein Computer an einer Variable rum, die ich in meinen Funktionen immer als Parameter übergeben habe, mit der Fehlermeldung <cannot find symbol>.
Ich setze hier mal den ganzen Quelltext rein, weil ich keinen blassen Schimmer habe, wo der Fehler ist, und die Fehlermeldungen :
Quelltext:
und die Fehlermeldungen:
Ich hatte jetzt bei den Fehlern mal die Pfeile rausgenommen, die auf den Fehler zeigen, weil sie durch das Pasten eh auf die falsche Stelle zeigen.
Denjenigen, die das Post bis hierher überflogen haben, bin ich schonmal total dankbar, ich lerne Java erst seit 2 Wochen und ich bin noch nicht soo damit vertraut, wie die Syntax hier läuft.
PS: der letzte Fehler (Z. 158) könnte sich inzwischen erledigt haben, ich hatte mich beim Namen der Prozedur <reflexiv> vertippt *g*
schon mal ein großes DANKE!
Ich hatte die Aufgabe, zu sagen, ob eine Funktion eine Relation darstellt oder nicht (ich glaube, wie das funktioniert ist bei meinem Problem eigentlich unwichtig, weil ich denke, ich habe das inhaltlich ganz gut hinbekommen), jetzt meckert nur mein Computer an einer Variable rum, die ich in meinen Funktionen immer als Parameter übergeben habe, mit der Fehlermeldung <cannot find symbol>.
Ich setze hier mal den ganzen Quelltext rein, weil ich keinen blassen Schimmer habe, wo der Fehler ist, und die Fehlermeldungen :
Quelltext:
Code:
/**
* @version <1.Uebungsblatt 1Aufgabe >
* @author < >
*/
// Importieren der benoetigten Funktionen zum Einlesen von Zahlen
import dssz.io.stdin;
/**
* Das Programm erwartet als Eingabe die Groesse einer quadratischen Matrix zur
* Speicherung einer Relation. Anschliessend wird die Relation als geordnetes
* Paar von positiven ganzen Zahlen eingelesen. Das Programm gibt aus, ob die
* Relation reflexiv, symmetrisch oder transitiv ist und ob es sich um eine
* Aequivalenzrelation handelt.
*/
public class Aequivalenz {
/**
* Die Funktion "readRel" ist Parameterlos. Sie liest die Groesse des
* zweidimensionalen Arrays in der die Relation gespeichert werden soll. Dann
* werden solange geordnete Paare der Relation eingelesen, bis eine Eingabe
* nicht mehr im gueltigen Bereich liegt (eingabe <0 oder eingabe >= size der
* quadratischen Matrix)
*
* @return zweidimensionales Array in dem die Relation gespeichert ist
*/
static boolean[][] readRel() {
boolean[][] relation = null;
int size = 0, x = 0, y = 0; // Eingabevariable
int i = 0, j = 0; //Laufvariablen
stdin eingabe = new stdin();// Tastatureingabe
// Schleife fuer Tastatureingabe, Absicherung und Fehlermeldung
do {
if ((size < 0) || (size > 20)) {
System.out.println("\nZahl zu gross oder zu klein.");
} // end if
size = eingabe.getInt("Groesse der Matrix: ");
} //end do while
while ((size < 0) || (size > 20));
relation = new boolean[size][size];
if (size == 0) {
return relation;
}// end if
//Eingabe der Groessen in die Reihung
for (i = 0; i < relation.length; i++) {
for (j = 0; j < relation[i].length; j++) {
relation[i][j] = false;
} // end for
} //end for
do {
x = eingabe.getInt("Geben Sie ein X ein: ");
y = eingabe.getInt("Geben Sie ein Y ein, dass zu X in Relation steht: ");
if ((x < 0) || (y < 0) || (x >= size) || (y >= size)) {
System.out
.println("Ende der Eingabe(aufgrund von Eingabewerten ausserhalb des gueltigen Bereichs:) ");
} else {
relation[x][y] = true;
} //end if
} //end do while
while ((x >= 0) && (y >= 0) && (x < size) && (y < size));
return relation;
} //end readRel
/**
* Die Funktion reflexiv untersucht die eingelesene Funtkion auf Reflexivität.
* Dabei wird geprüft, ob für jedes i Element Relation gilt, dass auch (i,i) Element der
* Relation ist.
*/
static boolean reflexiv(boolean[][] relation){
//Deklaration
int i=0; //Laufvariable
boolean refl=true; //es wird zunaechst angenommen, dass die Funktion reflexiv ist
//Verarbeitung
for (i=0; i<relation.length;i++) {
if (relation[i][i]==false) {
/*wenn es ein i Element Relation geben sollte, für das nicht gilt, dass (i,i)
nicht Element der Relation ist, so ist die Funktion nicht reflexiv */
refl=false
}//end if
}//end for
return refl;
}// end reflexiv
/**
* Die Funktion symmetrisch untersucht die eingelesene Funktion auf Symmetrie.
* Dabei wird für jedes Tupel (i,j) Element Relation untersucht, ob auch (j,i)
* Element der Relation ist
*/
static boolean symmetrisch(boolean[][] relation) {
//Deklaration
int i=0; int j=0;//Laufvariablen
boolean sym = true; //es wird zunaechst angenommen, dass symmetrie vorliegt
//Verarbeitung
for (i=0;i<relation.length;i++) {
for (j=0;j<relation.length;j++) {
if (relation[i][j]!=relation[j][i]{
sym=false;
}//end if
} //end j-Schleife
} //end i-Schleife
return sym;
}//end symmetrisch
/**
* Die Funktion transitiv untersucht die eingelesene Funktion auf Transitivitaet.
*/
static boolean transitiv(boolean [][] relation); {
//Deklaration
int i=0; int j=0; int k=0; //Laufvariablen
boolean trans=true; //zunächst wird angenommen, dass die Fkt. transitiv ist
//Verarbeitung
for (i=0; i<realation.length;i++) {
for(j=0; j<relation.length;i++) {
for (k=0; k<relation.length;k++) {
if ((relation[i][j]==true)&&(relation[j][k]==true)){
if (relation[i][k]==false) {
trans=false
}//end End-Bedingung fuer Transitivitaet
}//end Anfangsbedingungen fuer Transitivitaet
}//end k-Schleife
}/end j-Schleife
}//end i-SChleife
return trans;
}// end transitiv
/**
* Die Funktion "main" ruft die Funktion readRel und anschliessend die
* Funktionen reflexiv, symmetrisch, transitiv und speichert deren Ergebnis,
* an Hand dessen dann entschieden wird, ob es sich um eine
* Aequivalenzrelation handelt.
*
* @param argv wird ignoriert
*/
public static void main(String argv[]) {
boolean ref = false;
boolean symm = false;
boolean trans = false;
boolean[][] relation = null;
//Eingabe
relation = readRel();
boolean rel = false;
/*Hier muessen die Funktionsaufrufe und die Ausgabe ergaenzt werden */
//Verarbeitung
ref=reflexiv(relation);
symm=symmetrisch(relation);
trans=transitiv(relation);
//Ausgabe
if ((ref==true)&&(symm==true)&&(trans==true)) {
rel=true;
}
if (rel==true) { //wenn Relation, dann sage und zähle Eigenschaften auf
System.out.println("Es handelt sich um eine Relation, da sie sowohl reflexiv, als auch symmetrisch und transitiv ist");
} else { // sonst sage, dass keine Relation und sage über jede einzelne Eigenschaft, ob sie gilt oder nicht
System.out.println("Es handelt sich um keine Relation!");
if (ref==true) { //wenn reflexiv
System.out.println("Die Funktion ist reflexiv"); //dann sage, dass reflexiv
} else {
System.out.println("Die Funktion ist nicht reflexiv"); // sonst sage, dass nicht reflexiv
}
if (symm==true) { //wenn symmetrisch
System.out.println("Die Funktion ist symmetrisch"); //dann sage, dass symmetrisch
} else {
System.out.println("Die Funktion ist nicht symmetrisch"); //sonst sage, dass nicht symm.
}
if (trans==true) { //wenn transitiv
System.out.println("Die Funktion ist transitiv");//dann sage, dass transitiv
} else {
System.out.println("Die Funktion ist nicht transitiv"); //sonst sage, dass nicht trans.
}
}// end <keine Relation>
} //end main
} //end classund die Fehlermeldungen:
Code:
Aequivalenz.java:117: missing method body, or declare abstract
static boolean transitiv(boolean [][] relation); {
Aequivalenz.java:123: cannot find symbol
symbol : variable realation
location: class Aequivalenz
for (i=0; i<realation.length;i++) {
Aequivalenz.java:124: cannot find symbol
symbol : variable relation
location: class Aequivalenz
for(j=0; j<relation.length;i++) {
Aequivalenz.java:125: cannot find symbol
symbol : variable relation
location: class Aequivalenz
for (k=0; k<relation.length;k++) {
Aequivalenz.java:126: cannot find symbol
symbol : variable relation
location: class Aequivalenz
if ((relation[i][j]==true)&&(relation[j][k]==true)){
Aequivalenz.java:126: cannot find symbol
symbol : variable relation
location: class Aequivalenz
if ((relation[i][j]==true)&&(relation[j][k]==true)){
Aequivalenz.java:127: cannot find symbol
symbol : variable relation
location: class Aequivalenz
if (relation[i][k]==false) {
Aequivalenz.java:134: return outside method
return trans;
Aequivalenz.java:158: cannot find symbol
symbol : method reflexiv(boolean[][])
location: class Aequivalenz
ref=reflexiv(relation);Denjenigen, die das Post bis hierher überflogen haben, bin ich schonmal total dankbar, ich lerne Java erst seit 2 Wochen und ich bin noch nicht soo damit vertraut, wie die Syntax hier läuft.
PS: der letzte Fehler (Z. 158) könnte sich inzwischen erledigt haben, ich hatte mich beim Namen der Prozedur <reflexiv> vertippt *g*
schon mal ein großes DANKE!
