BigDecimal PQ Formel

[epsodus]

Hallo zusammen,

ich habe mir folgendes Programm geschrieben, welches auch funktioniert [edit SlaterB: inzwischen nicht mehr] :

  public class quat {
public static void main(String[] args) {
    long p = -101674619413903630355767678338069414612506706076925282022193699476386837870083900449467022296738245281885471904613673656547363537945392593808348756966097232229444108138303152491600220473423844878568921075095989542255854014313228073504238752492110779063298587625229257365079933581701564990668449090190124616884; 
    long q = 101674619413903630355767678338069414612506706076925282022193699476386837870083900449467022296738245281885471904613673656547363537945392593808348756966097253078563357867426643526069386885637059885198982078417801183249763667531836114130629212069834472470895419427969880763137032922483687362889407542522522141329; 
    double x1 = 0; 
    double x2 = 0; 
    
    x1 = -(p / 2) + Math.sqrt(Math.pow((p / 2), 2) - q); 
    x2 = -(p / 2) - Math.sqrt(Math.pow((p / 2), 2) - q); 
    
    System.out.println(x1); 
    System.out.println(x2); 
  }
  } [/Java]

So auf anraten eines Moderators versuche ich es noch einmal. Ich habe jetzt für p und q reale Zahlen eingetragen.
1. Das Programm möchte diese großen Zahlen nicht annehmen
2. Ich möchte das x1 und x2 auch als große Zahl errechnet wird. Am liebsten wäre mir alles mit Biginterger zu arbeiten, leider bin ich aber noch nicht soweit, deshalb hätte ich gerne Hilfe.

Epsodus

 

[SlaterB]

poste doch das Programm bitte mit BigInteger und passenden Beispielzahlen,
dann kann man vielleicht direkt darin verbessern

public class Test
{
    public static void main(String[] args)
    {
        BigInteger b = new BigInteger("23000000000000000000000000000000000000000000000000000000000000000000000000000000000");
        b = b.pow(10);
        System.out.println(b);
    }
}

gibt 800 Stellen einzeln aus..

 

[haui95]

Das ein Integer bei der Berechnung der Lösungen herauskommt ist eher unwahrscheinlich, deshalb würde ich eher ein BigDecimal verwenden.

 

[epsodus]

Hallo, ersteinmal Danke für die Tips. Das ist ja mein Problem, ob Biginteger oder BigDecimal, ich bekomme es nicht umgesetzt. Habe im Moent ein Brett vorm Kopf oder denke zu kompliziert.

 

[SlaterB]

na jetzt das ganze Programm klingt ja schon anders als vorher nur die Ergebnisausgabe
"In meinen anderen Programmen arbeite ich mit Biginterger. Als Ergbins kommt hier immer eine Zahl mit Exponentxx raus."

also BigDecimal in der Tat, keine Idee dazu?
new BigDecimal("lange Zahl");
bietet sich als initiale Eingabe an bzw. du bekommst die Zahlen vielleicht aus anderer Quelle als direkt Quelltext?
mindestens zum Testen aber geeignet

danach den Rest Rechenfall für Rechenfall erarbeiten,
nicht gerade in diesem Programm und auch lieber dann erstmal wieder mit kleinen Zahlen

da dir alles unbekannt ist, suche ich mir mal die einfache Subtraktion heraus :

public class Test {
    public static void main(String[] args)  {
        BigDecimal a = new BigDecimal("30");
        BigDecimal b = new BigDecimal("7");
        BigDecimal c = a.subtract(b);
        System.out.println(c);
    }
}

alles andere geht auch irgendwie mit bestimmten Befehlen, schaue dir das Angebot an, reche jeden Schritt Zeile für Zeile aus,
mit BigDecimal wird es leider ein großes Gewurschtel statt schick in einer Zeile,
kein Glanzpunkt von Java aber immerhin streng objektorientiert

für die beiden Zeilen 8 und 9 bietet sich vielleicht eine Untermethode statt Wiederholung an

 

[epsodus]

Hallo,

die original Formel die ich umsetzen möchte sieht so aus :

Q^2+(p-q-1)*Q+q=0

Für p und q setze ich zahlen ein, also eine Qudratische Gleichung auflösen. Mit kleinen Werten funktioniert der erste Quellcode.

 

[SlaterB]

falls relevant:
ich sehe keinen Sinn in dieser unvollständigen Formel [edit: jetzt vollständiger] und keinen Bezug auf mein Posting

etwas neues zu antworten hätte ich also auch nicht

 

[haui95]

Q^2+(p-q-1)*Q+q=0

Was ist das für eine Formel ? Benutze doch weiterhin die P-Q-Formel, die du oben schon angewandt hast, oder vllt. auch die Mitternachtsformel, um quadratische Gleichungen zu lösen.

MfG

 

[haui95]

So auf anraten eines Moderators versuche ich es noch einmal. Ich habe jetzt für p und q reale Zahlen eingetragen.

Ich glaube, du meinst reelle Zahlen. Jedoch sind p und q in deinem obigen Beispiel als Datentyp long deklariert, wobei long kein reeller Datentyp ist, sondern nur mit "größeren" Integern arbeiten kann, nämlich mit Zahlen bis zu 2^63 Bit mit Vorzeichen.

 

[epsodus]

so gehts wohl auch nicht :

import java.math.BigDecimal;

  public class quat {


 public static void main(String[] args) {
	 BigDecimal p = new BigDecimal("-101674619413903630355767678338069414612506706076925282022193699476386837870083900449467022296738245281885471904613673656547363537945392593808348756966097232229444108138303152491600220473423844878568921075095989542255854014313228073504238752492110779063298587625229257365079933581701564990668449090190124616884");
     BigDecimal q = new BigDecimal("101674619413903630355767678338069414612506706076925282022193699476386837870083900449467022296738245281885471904613673656547363537945392593808348756966097253078563357867426643526069386885637059885198982078417801183249763667531836114130629212069834472470895419427969880763137032922483687362889407542522522141329");
	 

    
     BigDecimal x1 = -(p / 2) + Math.sqrt(Math.pow((p / 2), 2) - q);
     BigDecimal x2 = -(p / 2) - Math.sqrt(Math.pow((p / 2), 2) - q);
     
       System.out.println(x1);
       System.out.println(x2);

 }    
  }

 

[haui95]

Probiere es einmal so !

public static void main(String[] args) { 
     BigInteger p = new BigInteger("-101674619413903630355767678338069414612506706076925282022193699476386837870083900449467022296738245281885471904613673656547363537945392593808348756966097232229444108138303152491600220473423844878568921075095989542255854014313228073504238752492110779063298587625229257365079933581701564990668449090190124616884");
     BigInteger q = new BigInteger("101674619413903630355767678338069414612506706076925282022193699476386837870083900449467022296738245281885471904613673656547363537945392593808348756966097253078563357867426643526069386885637059885198982078417801183249763667531836114130629212069834472470895419427969880763137032922483687362889407542522522141329");
     
 
     BigDecimal x1 = new BigDecimal(-(p / 2) + Math.sqrt(Math.pow((p / 2), 2) - q));
     BigDecimal x2 = new BigDecimal(-(p / 2) - Math.sqrt(Math.pow((p / 2), 2) - q));
     
     System.out.println(x1);
     System.out.println(x2);
 }

Was möchtest du denn überhaupt für p und q jetzt einsetzen ? BigInteger, also ganze Zahlen, oder BigDecimal, also reelle Zahlen ?

Die Zahlen in deinem Codeschnipsel sind nämlich ganze Zahlen, warum verwendest du denn dann BigDecimal ?

MfG

 

[epsodus]

Ganze Zahlen sind der Ursprung. Aber als Ergebnis kann auch ein BigDecimal auftauchen.

 

[J7Dev]

Aber sich mal die Doc durchlesen macht wieder kein *****.

Wenn man schon mit BigInteger/BigDecimal arbeitet ... dann sollte man nicht Math.* verwenden sondern die von BigInteger/BigDecimal zur verfügung gestellten Methoden. Die Math-Klasse ist nur für primitive Datentypen ausgelegt.

Mal davon abgesehen ...

@TO
Du weist schon das LONG einen Wertebereich von -9223372036854775808L bis 9223372036854775807L hat ... oder ? Das heißt dein erster Code ist schon mal totaler mist weil so riesige Zahlen gar nicht in einen LONG passen, wesshalb sich der Compiler wohl zu recht beschwert haben wird.




Ey ... erst die Wertebereiche der Datentypen mal voll ignorieren und dann nicht mal die Doc lesen können. Da wundert es mich nicht wirklich das selbst von "erfahrenen Usern" und Mods dann noch so falsche Tipps kommen wie "nutze doch Math.XXX() mit nem 200-Stellen BigInteger" ... super Hilfestellung, wirklich Freunde ... -.-'

 

[epsodus]

@TO
Du weist schon das LONG einen Wertebereich von -9223372036854775808L bis 9223372036854775807L hat ... oder ? Das heißt dein erster Code ist schon mal totaler mist weil so riesige Zahlen gar nicht in einen LONG passen, wesshalb sich der Compiler wohl zu recht beschwert haben wird.


Hi, klar weis ich das. Vorher standen dort 6 stellige Zahlen, damit funktionierte es auch. Dann wollte jemand die großen Zahlen dort eingetragen haben, hab ich gemacht. Ich hätte das Programm auch auf double double ändern können, hätte aber noch mehr Verwirrung gestiftet.

Was ich möchte ist : Die Eingangsvariablen sind immer ganze Zahlen, die Ausgangszahlen können durch die Berechnung auch BigDecimal sein.

Nur wie kann ich diese Formel umsetzen ?

 

[Wishmaster51]

Hi, klar weis ich das. Vorher standen dort 6 stellige Zahlen, damit funktionierte es auch. Dann wollte jemand die großen Zahlen dort eingetragen haben, hab ich gemacht. Ich hätte das Programm auch auf double double ändern können, hätte aber noch mehr Verwirrung gestiftet.

"double double" gibt es in Java nicht. Lies dir mal die Dokumentation zu [JAPI]BigDecimal[/JAPI] bzw [JAPI]BigInteger[/JAPI] durch, und zwar Schritt für Schritt.

 

[Landei]

Stand doch alles schon da: [c]+[/c] und [c]-[/c] und die restlichen Operatoren funktionieren weder für [c]BigInteger[/c] noch für [c]BigDecimal[/c] (Java unterstützt keine Operatorüberladung), dafür haben diese Klassen Methoden wie [c]add[/c], [c]subtract[/c] u.s.w.

 

[haui95]

Dafür gibt es keine Formel und dafür braucht man auch keine Formel, zumal man Zahlen mit sehr vielen Nachkommastellen bei der Berechnung der Lösungen von quadratischer Gleichung besser runden könnte, als dass man irgendwelche non-primitiven Datentypen verwendet. Du benötigst einfach nur die P-Q-Formel, um deine Berechnungen ausführen zu können.

double x1, x2;

double p = 16.178;
double q = 2.589;

x1 = -(p / 2) + Math.sqrt(Math.pow((p / 2), 2) - q); 
x2 = -(p / 2) - Math.sqrt(Math.pow((p / 2), 2) - q); 

System.out.println(x1);
System.out.println(x2);    // Als Ergebnis wirst du bestimmt eine reelle Zahl mit meheren Nachkommastellen herausbekommen. Diese kannst du runden oder einfach so lassen, wie sie ist (eher unschön). Wenn irgendwo ein e hoch x zu sehen ist, dann verwende meinetwegen BigDecimal, aber besser wäre es immer zu runden.