Aufsummieren von variablen Wertegrößen

[maxmuster987]

Ich bin gerade dabei das Massenträgheitsmoment zu berechnen.
Es ist eine Werkzeugbreite mit Radius gegeben, von der soll ich das Massenträgheitsmoment berechnen.
Die Formel für den Radius abhängig von x lautet: r(x)=15*x-(15/16)*x²
Die Formel für das Massenträgheitsmoment PRO Teilscheibe lautet: dJx=0,5*PI*rho*r(x)^4*dx

So, um nun das komplette Massenträgheitsmoment zu erhalten, muss ich alle dJx aufsummieren.
Aber jedes dJx ist logischerweise ein unterschiedlicher Wert, weil mein r(x) variabel ist bzw. abhängig vom x ist.

dJx1 = const*r(x1)^4
dJx2 = const*r(x2)^4
...
dJx200 = const*r(x200)^4

Jx = Aufsummierung aller dJx

Das hört sich ja nach einer Schleife an die von i=1 bis i<=200 läuft.

Das hier ist mein erster Versuch zumindest mal. Es geht um den case 2.
Ich will, dass jedes einzelne Massenträgheitsmoment in einem Feld gespeichert wird und anschließend sollen die alle aufaddiert werden.
Das bekomme ich doch irgendwie mit double jx = 0 als Initialisierung und anschließend jx +=dJx hin in einer Schleife und dann addiert sich das doch alles auf, oder?
Die Methode dJx soll aber dJx returnen. Also da darf ich nicht weiter rumspielen, das sollte eigentlich so passen. Ich denke mal, ich muss das dann direkt im case 2 lösen?

import java.io.*;
import javax.swing.*;
import java.util.*;

public class Uebung {
    public static void main (String[] args) {
 
        String modell = "Maschine XYZ 123";
        try {
            String modellKette = args[0]+" "+args[1]+" "+args[2];
            if(args.length!=3 | !(modellKette.equalsIgnoreCase(modell))) {
                System.out.println("Falsche Werkzeugmaschine - Programmabbruch -");
                System.exit(0);
            }
            else {
                System.out.println("Berechnungsprogramm fuer Werkzeugmaschine Modell \"" +modellKette+"\"");
                System.out.println("*************************************************");
            }
        }
        catch(ArrayIndexOutOfBoundsException e){
            System.out.println("Ungültige Anzahl Kommandozeilenparameter");
            System.out.println("- Programmabbruch -");
            System.exit(0);
        }
        boolean ende = true;
        final int rho = 7800;
        final int scheibenanzahl = 200;
        double x=0, b=0, dx=0;
        String eingabe;
        double dJxFeld[] = new double[scheibenanzahl];
        double rxFeld[] = new double[scheibenanzahl];

        while(ende){

            System.out.println("(1) Berechnungsparameter eingeben");
            System.out.println("(2) Massentraegheitsmoment berechnen und ausgeben");
            System.out.println("(3) Werte in Datei schreiben");
            System.out.println("==================================================");
            System.out.println("(0) Programm beenden");
      
            eingabe = JOptionPane.showInputDialog("Ihre Eingabe?\n Bitte Menuepunkt waehlen;");
            int wahl = Integer.parseInt(eingabe);
      
            switch(wahl){
                case 1:
                    eingabe = JOptionPane.showInputDialog("Startwert fuer x [mm]");
                    x = Double.parseDouble(eingabe);
                    eingabe = JOptionPane.showInputDialog("Breite b [mm]");
                    b = Double.parseDouble(eingabe);
                    dx = b/scheibenanzahl;
                    System.out.println("Dichte:\t\t"+rho+" [kg/m3]");
                    System.out.println("Startwert x:\t"+x+" [mm]");
                    System.out.println("Werkzeugbreite:\t"+b +" [mm]");
                break;
          
                case 2:
                            for(int i=0; i<200; i++) {
                                dJxFeld[i]=dJx(rho, x, dx);
                                //System.out.println("("+i+"): "+dJxFeld[i]);
                                x+=dx;
                            }
                break;
          
                case 3:
          
                break;
          
                case 0:
                    System.out.println("Programm beendet.");
                    ende=false;
                break;
          
            }
        }
        System.exit(0);
    }
 
    //Ab hier drunter Methoden:
    public static double dJx(double rho, double x, double dx) {
        return ((1/2.)*Math.PI*(rho/1000000000.)*Math.pow(rx(rho,x,dx),4)*dx);
    }
 
    public static double rx(double rho, double x, double dx) {
        return (15*x-(15/16.)*Math.pow(x,2));
    }
 
}

Ich hab mir das Ganze mal in Excel erstellt, um das nochmal visueller darzustellen, was ich eigentlich möchte. Vielleicht ist das auch hierfür sinnvoll, damit ihr mein Anliegen besser versteht.
Die einzelnen rx für bspw. x1 = 2 und b = 10. Und das jeweilige dJx. Rechts in gelb das Gesamtmassenträgheitsmoment nach Aufsummierung aller dJx.
x1 = 2
b = 10
x2 = 12 <- extra nochmal gesagt, weil die Breite ab x1 losgeht und dann bei x2, also 12 endet (nur falls das eine notwendige Information ist).


Nachtrag: Ich habe geprüft und case2: liefert schon mal das richtige x mit dem es rechnen soll. Also es zählt von 2 in 0,05 Schritten hoch bis 12.
(Diese 0,05 Schritte sind aber kein fester Wert. Der gilt nur bei Eingabe von x1 = 2 und b = 10, damit hier keine Missverständnisse entstehen).
Das x ist korrekt mit dem x+=dx.
Lol mein dJx ist sogar auch korrekt. Huch, was habe ich denn hier gemacht?😂
Jetzt muss ich nur noch mein Jx herausfinden mit dem Aufsummieren, aber das probiere ich gerade aus.

 

[maxmuster987]

Ich habe das Problem gelöst, alles gut. Jetzt bin ich stolz auf mich, ich habs tatsächlich selber hinbekommen

import java.io.*;
import javax.swing.*;
import java.util.*;

public class Uebung {
    public static void main (String[] args) {
    
        String modell = "Maschien XYZ 123";
        try {
            String modellKette = args[0]+" "+args[1]+" "+args[2];
            if(args.length!=3 | !(modellKette.equalsIgnoreCase(modell))) {
                System.out.println("Falsche Werkzeugmaschine - Programmabbruch -");
                System.exit(0);
            }
            else {
                System.out.println("Berechnungsprogramm fuer Werkzeugmaschine Modell \"" +modellKette+"\"");
                System.out.println("*************************************************");
            }
        }
        catch(ArrayIndexOutOfBoundsException e){
            System.out.println("Ungültige Anzahl Kommandozeilenparameter");
            System.out.println("- Programmabbruch -");
            System.exit(0);
        }
        boolean ende = true;
        final int rho = 7800;
        final int scheibenanzahl = 200;
        double x=0, b=0, dx=0;
        String eingabe;
        double jx = 0;
        double dJxFeld[] = new double[scheibenanzahl+1];
        double rxFeld[] = new double[scheibenanzahl+1];
        
        while(ende){
            try{
                System.out.println("(1) Berechnungsparameter eingeben");
                System.out.println("(2) Massentraegheitsmoment berechnen und ausgeben");
                System.out.println("(3) Werte in Datei schreiben");
                System.out.println("==================================================");
                System.out.println("(0) Programm beenden");
                
                eingabe = JOptionPane.showInputDialog("Ihre Eingabe?\nBitte Menuepunkt waehlen;");
                int wahl = Integer.parseInt(eingabe);
                
                    switch(wahl){
                        case 1:
                            eingabe = JOptionPane.showInputDialog("Startwert fuer x [mm]");
                            x = Double.parseDouble(eingabe);
                            eingabe = JOptionPane.showInputDialog("Breite b [mm]");
                            b = Double.parseDouble(eingabe);
                            dx = b/scheibenanzahl;
                            System.out.println("Dichte:\t\t"+rho+" [kg/m3]");
                            System.out.println("Startwert x:\t"+x+" [mm]");
                            System.out.println("Werkzeugbreite:\t"+b +" [mm]");
                        break;
                        
                        case 2:
                            for(int i=0; i<=200; i++) {
                                dJxFeld[i]=dJx(rho, x, dx);
                                //System.out.println("("+i+"): "+dJxFeld[i]+"\t "+x);
                                x+=dx;
                                jx+=dJxFeld[i];
                            }
                            System.out.println("Massentraegheitsmoment: "+jx);

                        break;
                        
                        case 3:
                        
                        break;
                        
                        case 0:
                            System.out.println("Programm beendet.");
                            ende=false;
                        break;
                        default:
                            System.out.println("\nFalsche Zahleingabe - bitte erneut.\n");
                        break;
                        
                    }
            }
            catch (NumberFormatException e) {
                System.out.println("\nString, statt Zahl eingegeben - bitte erneut.\n");
            }
        }
        System.exit(0);
    }
    
    //Ab hier drunter Methoden:
    public static double dJx(double rho, double x, double dx) {
        return ((1/2.)*Math.PI*(rho/1000000000.)*Math.pow(rx(rho,x,dx),4)*dx);
    }
    
    public static double rx(double rho, double x, double dx) {
        return (15*x-(15/16.)*Math.pow(x,2));
    }
    
}

So sieht es aktuell aus. Falls ihr noch Verbesserungsvorschläge habt, dann her damit.
Ich schreibe noch kurz case 3: zu Ende.

 

[Oneixee5]

Es gibt einen Unterschied zwischen bitweisem oder und logischem oder - mit if verwendet man normalerweise das logische oder:

if(args.length!=3 | !(modellKette.equalsIgnoreCase(modell)))

if(args.length!=3 || ...

 

[Oneixee5]

Hier wird try-catch zur Programmsteuerung verwendet, das tut man nicht. Man kann einfach mit args.length herausfinden, ob genügend Parameter vorhanden sind.

        try {
            String modellKette = args[0]+" "+args[1]+" "+args[2];
            ...
        } catch(ArrayIndexOutOfBoundsException e) {
            ...

 

[maxmuster987]

Schau mal, ich hab die Anfangsbedingung abgeändert mit if - else if - else.
Sieht das so besser aus als vorher?

Ein Problem ist mir allerdings noch aufgefallen, bei case 3 beim Schreiben einer Datei.
Der zieht sich das x, also den Startwert aus dem vorherigen Case (Zeile 60) (logisch, weil aktuelles x). Und dort ist das x ja das aufsummierte x nach jedem Schleifendurchgang.
Und ich benötige in Zeile 74 ja mein x aus der Eingabe aus Zeile 47.

import java.io.*;
import javax.swing.*;
import java.util.*;

public class Uebung {
    public static void main (String[] args) {
   
        String modell = "Maschine XYZ 123";
        String modellKette = args[0]+" "+args[1]+" "+args[2];
       
        if(args.length==3 && modellKette.equalsIgnoreCase(modell)){
            System.out.println("Berechnungsprogramm fuer Werkzeugmaschine Modell \"" +modellKette+"\"");
            System.out.println("*************************************************");  
        }
        else if (args.length!=3) {
            System.out.println("Anzal Kommandozeilenparameter ungleich 3");
            System.exit(0);
        }
        else {
            System.out.println("Falsche Maschineneingabe.");
            System.exit(0);
        }

        boolean ende = true;
        final int rho = 7800;
        final int scheibenanzahl = 200;
        double x=0, b=0, dx=0;
        String eingabe;
        double jx = 0;
        double dJxFeld[] = new double[scheibenanzahl+1];
        double rxFeld[] = new double[scheibenanzahl+1];
       
        while(ende){
            try{
                System.out.println("(1) Berechnungsparameter eingeben");
                System.out.println("(2) Massentraegheitsmoment berechnen und ausgeben");
                System.out.println("(3) Werte in Datei schreiben");
                System.out.println("==================================================");
                System.out.println("(0) Programm beenden");
               
                eingabe = JOptionPane.showInputDialog("Ihre Eingabe?\nBitte Menuepunkt waehlen;");
                int wahl = Integer.parseInt(eingabe);
               
                    switch(wahl){
                        case 1:
                            eingabe = JOptionPane.showInputDialog("Startwert fuer x [mm]");
                            x = Double.parseDouble(eingabe);
                            eingabe = JOptionPane.showInputDialog("Breite b [mm]");
                            b = Double.parseDouble(eingabe);
                            dx = b/scheibenanzahl;
                            System.out.println("Dichte:\t\t"+rho+" [kg/m3]");
                            System.out.println("Startwert x:\t"+x+" [mm]");
                            System.out.println("Werkzeugbreite:\t"+b +" [mm]");
                        break;
                       
                        case 2:
                            for(int i=0; i<=200; i++) {
                                dJxFeld[i]=dJx(rho, x, dx);
                                //System.out.println("("+i+"): "+dJxFeld[i]+"\t "+x);
                                x+=dx;
                                jx+=dJxFeld[i];
                            }
                            System.out.println("\nJx = "+jx +" [kg*mm2]\n");

                        break;
                       
                        case 3:
                            FileWriter fileW;
                            try {
                                fileW = new FileWriter("Werte.csv");
                               
                                fileW.write("Massentraegheitsmoment fuer " +modellKette+"\n");
                                fileW.write("rho = "+rho+" [kg/m3]\n");
                                fileW.write("Startwert x = "+x +" [mm]\n");
                                fileW.write("Werkzeugbreite = "+b +" [mm]\n");
                                fileW.write("Jx = "+jx +"\n");
                                for(int i=0; i<=200; i++) {
                                    fileW.write("\n" +dJxFeld[i]);
                                }

                                fileW.close();
                            }          
                            catch (IOException e) {
                                System.out.println("Ergebnisausgabe fehlgeschlagen.");
                            }
                        break;
                       
                        case 0:
                            System.out.println("Programm beendet.");
                            ende=false;
                        break;
                        default:
                            System.out.println("\nFalsche Zahleingabe - bitte erneut.\n");
                        break;
                       
                    }
            }
            catch (NumberFormatException e) {
                System.out.println("\nString, statt Zahl eingegeben - bitte erneut.\n");
            }
        }
        System.exit(0);
    }
   
    //Ab hier drunter Methoden:
    public static double dJx(double rho, double x, double dx) {
        return ((1/2.)*Math.PI*(rho/1000000000.)*Math.pow(rx(rho,x,dx),4)*dx);
    }
   
    public static double rx(double rho, double x, double dx) {
        return (15*x-(15/16.)*Math.pow(x,2));
    }
   
}

 

[Oneixee5]

Das

String modellKette = args[0]+" "+args[1]+" "+args[2];

führt zu einem Programmabbruch, wenn Parameter fehlen.

Das muss als erstes ausgeführt werden:

if (args.length!=3) {
    System.out.println("Anzal Kommandozeilenparameter ungleich 3");
    System.exit(0);
}

Dann wird auch kein 'else' benötigt, weil das Programm einfach zu Ende ist, wenn die Bedingung trifft.
Es würde, statt System.exit(0);, auch einfach ein 'return' genügen, da du als Exit-Code immer 0 zurück gibst. Also mit dem Exit-Code kannst du keine Fehler unterscheiden und der Exit-Code wird in die ERRORLEVEL-Umgebungsvariable übertragen - dabei beutet '0' soviel wie 'erfolgreich'.

 

[maxmuster987]

führt zu einem Programmabbruch, wenn Parameter fehlen.

Stimmt, auch nicht dran gedacht, wenn keine Parameter eingegeben werden zunächst.

Aber ich will ja unterscheiden zwischen:

Falsche Maschineneingabe = 3 Parameter eingegeben, aber nicht mit String modell = "" übereinstimmend.
Richtige Maschineneingabe = 3 Parameter eingegeben UND mit String modell ="" übereinstimmend.
Falsche Anzahl Kommandozeilenparameter = alles ungleich 3

Brauche ich dann nicht doch das else?

Das muss als erstes ausgeführt werden:

if (args.length!=3) {
    System.out.println("Anzal Kommandozeilenparameter ungleich 3");
    System.exit(0);
}

Wie füge ich denn jetzt mein:

String modellKette = args[0]+" "+args[1]+" "+args[2];

an den richtigen Punkt ein?

Habe jetzt das ungleich 3 an erster Stelle gesetzt, falls nichts angegeben, dann direkt Programmabbruch, sonst Kontrolle der weiteren Punkte.

        String modell = "Maschine XYZ 123";

        
        if (args.length!=3) {
            System.out.println("Anzal Kommandozeilenparameter ungleich 3");
            System.exit(0);
        }
            //    String modellKette = args[0]+" "+args[1]+" "+args[2];
        else if(args.length==3 && modellKette.equalsIgnoreCase(modell)){
            System.out.println("Berechnungsprogramm fuer Werkzeugmaschine Modell \"" +modellKette+"\"");
            System.out.println("*************************************************");   
        }
        
        else {
            System.out.println("Falsche Maschineneingabe.");
            System.exit(0);
        }

Oder muss ich das Problem mit der Eingabe KEINER Parameter mit einem try-catch ArrayIndexOutOfBoundsException lösen?

 

[Oneixee5]

Bei "case 3" sind wir noch längst nicht angekommen.

final int scheibenanzahl = 200; // das ist eigentlich ein Konstante
...
double dJxFeld[] = new double[scheibenanzahl+1]; // wozu +1? kann man doch den richtigen Wert nehmen
...
// und dann machst du sowas!?
for(int i=0; i<=200; i++) {
    dJxFeld[] ...
}
// warum nicht:
for (int i = 0; i < dJxFeld.length; i++) {
    dJxFeld[] ...
}

 

[maxmuster987]

// warum nicht: for (int i = 0; i < dJxFeld.length; i++) { dJxFeld[] ... }

Kann ich dir sagen, weil ich dann das falsche Ergebnis erhalte. Mir fehlt dann genau der letzte Wert, um das richtige Jx zu erhalten.
So würde ich auf 978,184... kommen.

Aber wie ich es gemacht habe, komme ich auf meine korrekten 980,696...
Ich habe ja quasi 201 Werte, deswegen.

 

[Oneixee5]

        String modell = "Maschine XYZ 123";        
        if (args.length != 3) {
            System.out.println("Anzal Kommandozeilenparameter ungleich 3");
            return;
        }
        // hier ist args.length immer 3, also args.length==3 ist sinnlos!
        String modellKette = args[0]+" "+args[1]+" "+args[2];
        if (modellKette.equalsIgnoreCase(modell)) {
            System.out.println("Berechnungsprogramm fuer Werkzeugmaschine Modell \"" + modellKette + "\"");
            System.out.println("*************************************************");   
        } else {
            System.out.println("Falsche Maschineneingabe.");
            return;
        }

equalsIgnoreCase - ist auch Quatsch da du die Eingabe von Ziffern erwartest, es gibt keine klein oder groß geschrieben Ziffern.

Wenn die Parameter 1, 2 und 3 sind, dann ist modellKette == "1 2 3"! immer mit Leerzeichen getrennt - das ist nie gleich: "Maschine XYZ 123";

 

[Oneixee5]

Mir fehlt dann genau der letzte Wert,

Das ist Quatsch.

        final double [] dJxFeld = { 1d, 2d, 3d };
        for (int i = 0; i < dJxFeld.length; i++) {
            System.out.println(dJxFeld[i]);
        }

ergibt:

1.0
2.0
3.0

 

[maxmuster987]

equalsIgnoreCase - ist auch Quatsch da du die Eingabe von Ziffern erwartest, es gibt keine klein oder groß geschrieben Ziffern.

Wenn die Parameter 1, 2 und 3 sind, dann ist modellKette == "1 2 3"! immer mit Leerzeichen getrennt - das ist nie gleich: "Maschine XYZ 123";

Wenn ich jetzt equalsIgnoreCase rausnehme, dann ist das doch falsch?

Eingabe: MasCHine XyZ 123
Würde jetzt zu einer Fehleingabe führen, weil ja mit dem String = "Maschine XYZ 123" verglichen wird. Da wird doch dann auf Groß- und Kleinschreibung geachtet.
Ich will aber, dass MasCHine XyZ 123 ebenfalls als korrekt gewertet wird, egal ob groß oder klein.

 

[maxmuster987]

Das ist Quatsch.

Du hast mal wieder recht! Ich hab auf meine Excel-Liste geschaut und die fängt bei 1 an zu zählen, deswegen steht da am Ende 201...

Aber irgendwie kommt trotzdem das falsche Ergebnis heraus, wenn ich hiermit löse:

// warum nicht: for (int i = 0; i < dJxFeld.length; i++) { dJxFeld[] ... }

Im Anhang habe ich nochmal das Ganze dargestellt.
Links die Laufvariable läuft von 0 bis 200 bzw. im Programm von 0 bis 199.

 

[maxmuster987]

Doch, warte. Es sind tatsächlich 201 Werte, dann habe ich das doch nicht falsch gesagt. 🤨

Jetzt ist die Frage, was ich hier falsch mache.

Aus der Aufgabenstellung sind Beispielwerte angegeben für x=2 und b=10.

Dort ist dann die Lösung für das Massenträgheitsmoment Jx = 979.30871.

Wenn ich es mache wie du, dann ist die Lösung: 978.1845
Wenn ich meine Excel-Liste frage, dann ist die Lösung: 980.6966

Der Excel-Liste traue ich momentan am meisten.

 

[Oneixee5]

Also wenn ich die Schleife wie folgt verwende:

                    for (int i = 0; i < dJxFeld.length; i++) {
                        dJxFeld[i] = dJx(rho, x, dx);
                        x += dx;
                        jx += dJxFeld[i];
                    }

erhalte ich als Ergebnis:

Berechnungsprogramm fuer Werkzeugmaschine Modell "Maschine XYZ 123"
*************************************************
(1) Berechnungsparameter eingeben
(2) Massentraegheitsmoment berechnen und ausgeben
(3) Werte in Datei schreiben
==================================================
(0) Programm beenden
Dichte:        7800 [kg/m3]
Startwert x:    2.0 [mm]
Werkzeugbreite:    10.0 [mm]
(1) Berechnungsparameter eingeben
(2) Massentraegheitsmoment berechnen und ausgeben
(3) Werte in Datei schreiben
==================================================
(0) Programm beenden

Jx = 980.6966090510297 [kg*mm2]

(1) Berechnungsparameter eingeben
(2) Massentraegheitsmoment berechnen und ausgeben
(3) Werte in Datei schreiben
==================================================
(0) Programm beenden
Programm beendet.

 

[maxmuster987]

Also wenn ich die Schleife wie folgt verwende:
Java:

                    for (int i = 0; i < dJxFeld.length; i++) {
                        dJxFeld[i] = dJx(rho, x, dx);
                        x += dx;
                        jx += dJxFeld[i];
                    }

Wieso bekommst du das richtige Ergebnis und ich nicht

Dein dJxFeld.length ist doch 200 oder nicht?
Wenn jetzt i von 0 bis 199 läuft, dann hast du doch auch den 201. Wert nicht drin? Ich verstehe es nicht...

 

[Oneixee5]

        final int scheibenanzahl = 200;
        double dJxFeld[] = new double[scheibenanzahl+1];
        double rxFeld[] = new double[scheibenanzahl+1];

dJxFeld.length ist 201 und nicht 200.
rxFeld wird nirgendwo verwendet.

 

[maxmuster987]

dJxFeld.length ist 201 und nicht 200.

Sag das doch gleich, Mensch.

double dJxFeld[] = new double[scheibenanzahl+1]; // wozu +1? kann man doch den richtigen Wert nehmen

Weil ich war auf deinem Stand, dass du die +1 aus dem Feld ganze Zeit rausgenommen hast...😫

rxFeld wird nirgendwo verwendet.

Ja, das weiß ich. Das hatte ich ganz zu Beginn nur geschrieben, weil ich gedacht habe, dass ich das noch gleich brauchen werde. Aber habs danach einfach nicht mehr entfernt.