Java-Programm zur Berechnung globaler Minimas und Maximas-ff

  • Themenstarter Themenstarter Plonkman
  • Beginndatum Beginndatum
Status
Nicht offen für weitere Antworten.
P

Plonkman

Gast
Guten Tag, ich habe nun ein Programm geschrieben das mir von einer polynomfunktion das globale minima und maxima errechnen soll. Nun bin ich aber an einem Punkt angelangt wo ich nicht mehr weiterkomme, die Berechnung ist das Problem. Als Anhang habe ich den Quellcode des Programms beigelegt!

Code:
/******************************************************

             Autor: Plonkman
        Erstellungsdatum: 07.12.2006
  Letztes Änderungsdatum: 16.12.2006

******************************************************/
import java.awt.*;
import java.awt.event.*;
import java.text.*;


class fenster extends Frame
{
	
			
	private Button btn_start;
	private Button btn_graduebernahme;
	private Button btn_werte;
	private TextField gradeingabe;
	private TextField globmaximum;
	private TextField globminimum;
	private TextField lokmaximum;
	private TextField lokminimum;
	private Label grad;
	private Label labelglobmax;
	private Label labelglobmin;
	private Label labellokmax;
	private Label labellokmin;
	private Label funktion;
	private Label leer;
	private Label leer2;
	private Label[] labels;
	private String zwischentext;
	private int grad2;
	private NumberFormat nf;
	private TextField[] txfelder;
	private int i;
	private Panel panel;
	private Panel panel2;
	
	
	
	// ActionListener der Komponenten definieren
	class B_ActionListener implements ActionListener
	{
		public void actionPerformed(ActionEvent e)
		{
		
			zwischentext = gradeingabe.getText();
		    grad2 = Integer.parseInt(zwischentext)+1;
		    txfelder=new TextField[grad2];
		    labels= new Label[grad2];
		    
		    for(int i = 0; i<grad2; i++)
		    {
		    	txfelder[i]=new TextField();
		    	panel.add(txfelder[i]);
		    	labels[i]=new Label("x"+(grad2-i-1));
		    	panel.add(labels[i]);
		    	panel.validate();
		    	System.out.println("in schleife");
		    }
	
			System.out.println("ausser schleife");
	
			
		}
	}
	
	class C_ActionListener implements ActionListener
	{
		public void actionPerformed(ActionEvent e)
		{
 			
 			String gleichung;
 			gleichung = txfelder[0];
 			
 			
 			funktion.setText(gleichung);
 			
		}
	}
	
	
	// Berechnung DIO CAN!
	
	class D_ActionListener implements ActionListener
	{
		public void actionPerformed(ActionEvent e)
		{
			System.out.println("Ich kriegs in die Nerven");
		}
	}
	
	
	
	// WindowListener zum Schließen des Fensters
	class W_WindowListener extends WindowAdapter
	{
		public void windowClosing(WindowEvent e)
		{
			// Das Programm beenden
			System.exit(0);
		}
	}
	
	
	
	// Konstruktor des Fensters
	fenster(String titel)
	{
		// Konstruktor der Basisklasse aufrufen
		super(titel);
		
		
		// Instanzen der verschiedenen Komponenten erzeugen
		leer = new Label("");
		leer2 = new Label("");
		btn_werte = new Button("Werte übernehmen!");
		btn_start = new Button("<-- START -->");
		btn_graduebernahme = new Button("[Grad übernehmen]");
		grad = new Label("Geben Sie den Grad der Funktion ein:");
		gradeingabe = new TextField("");
		funktion = new Label("");
		labelglobmax = new Label("Globales Maximum:");
		labelglobmin = new Label("Globales Minimum:");
		labellokmax = new Label("Lokales Maximum:");
		labellokmin = new Label("Lokales Minimum:");
		globmaximum = new TextField("");
		globminimum = new TextField("");
		lokmaximum = new TextField("");
		lokminimum = new TextField("");		
		panel = new Panel();
		panel2 = new Panel();
		// Layout-Manager zum Anordnen der Komponenten
		setLayout(new GridLayout(2,1));
		panel2.setLayout(new GridLayout(7,2));
		
		
		// Komponenten zum Fenster hinzufügen (registrieren)
		panel.setBackground(java.awt.Color.red);
		
		
				
		
		panel2.add(grad);
		panel2.add(gradeingabe);
		panel2.add(btn_graduebernahme);
		panel2.add(leer2);
		panel2.add(btn_start);
		panel2.add(leer);
		panel2.add(labelglobmax);
		panel2.add(globmaximum);
		panel2.add(labelglobmin);
		panel2.add(globminimum);
		panel2.add(labellokmax);
		panel2.add(lokmaximum);
		panel2.add(labellokmin);
		panel2.add(lokminimum);
		
		
		panel.add(btn_werte);
		panel.add(funktion);
		add(panel2);
		add(panel);
		// Actionslistener der Komponenten registrieren
		
		btn_graduebernahme.addActionListener(new B_ActionListener());
		btn_werte.addActionListener(new C_ActionListener());
		
		// den Frame bei einem WindowListener registrieren
		addWindowListener(new W_WindowListener());
		
	}
}
class projekt
{
	
	public static void main(String[] args)
	{
		// Instanz der Fensterklasse anlegen
		fenster F1 = new fenster("Projekt, Hecher, Verdorfer, Aichner, Raffin");
		F1.setSize(640,480);
		F1.pack();
		F1.setVisible(true);
		
	}
}

// EOF: fenster_template.java

also wenn man beim programm oben den grad eingibt und uebernimmt so erscheinen die einzelnen textfields wo man die werte der polynomfunktion eingeben kann. Jedoch wie errechne ich nun globales minimum und maximum?

Ich bitte um Hilfe.

mfg.
Plonkman
 
1. immer noch: globales Minimum/Maximum und mehrere Minima und Maxima!

2. du hast also die GUI geschrieben... okay... hast du dir denn Gedanken gemacht, wie man das eigentliche Problem lösen könnte? Wie berechnet man denn per Hand Minima/Maxima einer Funktion?
Was für Vorraussetzungen sind gegeben an diese Funktion - offensichtlich handelt es sich immer um ein Polynom, d.h. um Funktionen die in etwa so aussehen: 3x^3+2x^2+x-5 ?
 
bingo genau so sollte z.b. eine funktion aussehen. ich habe mal an eine wertetabelle gedacht aber ich glaube das haut nicht so ganz hin!
 
Naja die Wertetabelle wäre für's Zeichnen schon ganz angebracht... du machst dir ne variablen Schrittlänge und berechnest dann von den mit anzugebenden Grenzen (z.B. -5, +5 Schrittlänge 0,1) alle Werte dazwischen und kannst die Punkte dann schonmal zeichnen... - je kleiner du die Schrittlänge wählst, desto hübscher wird die kurve 😉

zum Berechnen der Minima/Maxima... normalerweise macht man das ja so, dass man die Nullstellen der 1. Ableitung berechnet... - mathematisch Lösen kann man das bei Funktionen 3. Grades noch sehr easy über die p-q-Formel... danach wird das Berechnen der Nullstellen aber schwieriger... daher gehe ich mal davon aus (wenn du auch größere Funktionen n-ten Grades berechnen sollst), dass du die Nullstellen numerisch berechnen musst... dafür gibt es versch. Methoden, wie z.B. das Newton-Verfahren, über das du dir mal Informationen einholen solltest... z.B. über die wikipedia.
 
koenntest du mir bitte ein praktisches beispiel liefern, wenn moeglich auch mit code?
tausend dank.
 
Status
Nicht offen für weitere Antworten.

Neue Themen


Zurück
Oben