Berechnung der Kühlung Java

[Abraham42]

Eine Methode zur Berechnung des Abkuehlverhaltens einer Teetasse unter der Annahme, dass sich die Temperatur des Tees jede Minute um ein Fünftel der Differenz von Teetemperatur und Zimmertemperatur verringert.
Ich versuch zu wissen, wie lange der Tee zum Abkühlen braucht.

Sollte nach 200 Minuten die gewünschte Temperatur nicht erreicht sein, soll die Berechnung abgebrochen werden. Das habe ich bisher geschrieben, aber aus irgendeinem Grund funktioniert es nicht richtig...

public class Teetasse
{
 
    public int abkuehlung(double atemp, double ztemp, double wtemp)
    {
        double temp=0;
        double temp2=0;
        int f=0;

        temp =atemp-ztemp;
        temp2=temp;
            while ( temp2>=wtemp){
                if (f>=200 && temp2>wtemp){
               f=200;
               return f;
            }
                temp2=temp2-0.2;
            f=f+1;
        }
            
    
     return f;
}
}

 

[kneitzel]

Benennen die Variablen sinnvoll. Du wirfst alles durcheinander und da kann dann nichts sinnvolles bei rauskommen.

Evtl. beschreibst du es auch erst einmal mit Worten, damit du dann auch klar weisst, was du alles an Werten hast und was diese bedeuten.

 

[mihe7]

Das lässt sich schön mathematisch lösen. Gegeben seien eine Zimmertemperatur T_z, eine Ausgangstemperatur des Tees T_0, außerdem eine Wunschtemperatur für den Tee T_w.

Voraussetzungen, dass sich der Tee auf die Wunschtemperatur abkühlen kann, sind:

• T_w < T_0
• T_w > T_z (Gleichheit gilt nicht, da die Abnahme prozentual erfolgt und man sich somit der Zimmertemperatur nur beliebig nah annähern kann)

Es muss also T_z < T_w < T_0 gelten. Ist dies der Fall, kann man die Temperatur nach n Minuten berechnen:
T(n) := T_z + (T_0 - T_z) (100 % - 20 %)^n = T_z + (T_0 - T_z) 0,8^n

Die Frage ist, wie groß ist n, damit T(n) = T_w gilt?

T_w = T_z + (T_0 - T_z) 0,8^n <=> (T_w - T_z) / (T_0 - T_z) = 0,8^n
=> n = log_0,8 ((T_w - T_z) / (T_0 - T_z))

Soll n eine ganze Zahl sein, wobei angefangene Minuten ganz gerechnet werden, wäre die Aufrundungsfunktion (ceil) zu verwenden.

Bezogen auf Deine Parameter:

int n = (int) Math.ceil(Math.log((wtemp - ztemp)/(atemp - ztemp)) / Math.log(0,8));

 

[Abraham42]

Die Variablen bedeuten:
atemp: Anfangstemperatur
ztemp: Zimmertemperatur
wtemp: gewünschte Temperatur des Tees

 

[kneitzel]

Die Variablen bedeuten:
atemp: Anfangstemperatur
ztemp: Zimmertemperatur
wtemp: gewünschte Temperatur des Tees

Aber das sind ja nicht die ganzen Variablen, die Du benutzt hast...

Hast Du einmal versucht, das mal etwas durchzuspielen? Stift und Papier nehmen und mal von Hand durchspielen, was da das Programm machen soll?

Tee hat 90°, Zimmertemperatur ist 22°, Wunschtemperatur ist 38°

Kannst Du das einmal durchspielen?

Das nennt sich übrigens "Verständnis der Problemdomäne". Du musst als erstes verstehen, was da passiert und wie es sich verhält. Dann kann man auf rein mathematische Berechnungen kommen, wie @mihe7 gezeigt hat (auch wenn es bei einer Programmierübung wenig hilfreich ist...) und man kann es dann auch programmieren...

Wenn Du das, was da abläuft und das Verhalten nicht verstanden hast, dann kann da nichts bei raus kommen.

Daher nimm mal das Beispiel: Tee hat 90°, Zimmertemperatur ist 22°, Wunschtemperatur ist 38°
Wie sieht es nach 1 min aus? Wie nach 2 min?

Kannst Du das berechnen?

 

[mihe7]

auch wenn es bei einer Programmierübung wenig hilfreich ist...

Das war Zweck der Sache

Mit etwas Verständnis sollte er nämlich

Daher nimm mal das Beispiel: Tee hat 90°, Zimmertemperatur ist 22°, Wunschtemperatur ist 38°
Wie sieht es nach 1 min aus? Wie nach 2 min?

berechnen können und letztlich auf die Formeln kommen bzw. die Analogie erkennen. Ist zumindest meine Hoffnung.

 

[ImmerDieseKinder]

Das ist ja alles so viel hin und her... Wenn man die Formel nicht verwenden darf (also log ...) dann hätte ich es so gemacht:

    public static double teeMinuten(double umgebung, double start, double wunsch, double teeAktuell, double minAktuell, double faktor1, double faktor2) {
        double temp = (teeAktuell - umgebung) * faktor1 + umgebung;
        while (temp > wunsch) {
            teeAktuell = temp;
            minAktuell += faktor2;
            temp = (teeAktuell - umgebung) * faktor1 + umgebung;
        }

        if (teeAktuell - wunsch > 1.0e-3) {
            return teeMinuten(umgebung, start, wunsch, teeAktuell, minAktuell, Math.pow(faktor1, 1.0 / 10.0), faktor2 / 10);
        }
        return minAktuell;
    }

    public static void main(String[] args) {
        System.out.println(teeMinuten(20, 90, 25, 90, 0, 0.8, 1));
    }

Ein 90Grad heißer Tee kühlt sich also nach 11,826 Minuten auf 25Grad ab, bei einer Umgebungstemperatur von 20 und einem 0,8-Faktor. Das Ganze hat sich glaube ich Newton ausgedacht.

 

[Abraham42]

Aber das sind ja nicht die ganzen Variablen, die Du benutzt hast...

Hast Du einmal versucht, das mal etwas durchzuspielen? Stift und Papier nehmen und mal von Hand durchspielen, was da das Programm machen soll?

Tee hat 90°, Zimmertemperatur ist 22°, Wunschtemperatur ist 38°

atemp: Anfangstemperatur
ztemp: Zimmertemperatur
wtemp: gewünschte Temperatur des Tees
min:Anzahl der Minuten, damit der Tee abkühlt
tee:die Temperatur des Tees
faktor:so wie ich es verstehe, ist 1/5 = 20%, dann subtrahiert man von 100% 20%, was 80% entspricht, also 0,8
temp:die abnehmende Temperatur

"Tee hat 90°, Zimmertemperatur ist 22°, Wunschtemperatur ist 38°"
Der Tee erreicht in 6 Minuten eine Temperatur von 38 ° C.

"Wie sieht es nach 1 min aus? Wie nach 2 min?"
Nach einer Minute beträgt die Temperatur 76,4
dann, nach zwei Minuten, beträgt die Temperatur 65,52

 

[Abraham42]

T_w = T_z + (T_0 - T_z) 0,8^n <=> (T_w - T_z) / (T_0 - T_z) = 0,8^n
=> n = log_0,8 ((T_w - T_z) / (T_0 - T_z))

Vielen Dank für die Erklärung!

Aber das sind ja nicht die ganzen Variablen, die Du benutzt hast...

Hast Du einmal versucht, das mal etwas durchzuspielen? Stift und Papier nehmen und mal von Hand durchspielen, was da das Programm machen soll?

Tee hat 90°, Zimmertemperatur ist 22°, Wunschtemperatur ist 38°

atemp: Anfangstemperatur
ztemp: Zimmertemperatur
wtemp: gewünschte Temperatur des Tees
min:Anzahl der Minuten, damit der Tee abkühlt
tee:die Temperatur des Tees
faktor:so wie ich es verstehe, ist 1/5 = 20%, dann subtrahiert man von 100% 20%, was 80% entspricht, also 0,8
temp:die abnehmende Temperatur

"Tee hat 90°, Zimmertemperatur ist 22°, Wunschtemperatur ist 38°"
Der Tee erreicht in 6 Minuten eine Temperatur von 38 ° C.

"Wie sieht es nach 1 min aus? Wie nach 2 min?"
Nach einer Minute beträgt die Temperatur 76,4 und nach zwei 65.62

 

[Abraham42]

Der Code sieht jetzt so aus, aber es gibt ein Problem, zum Beispiel, wenn ich die Werte: Tee=90 °, Zimmertemperatur=20 °, Wunschtemperatur=10, wenn die gewünschte Temperatur und die Zimmertemperatur gleich sind, wird die Schleife niemals enden.

Ich habe dieses Beispiel verwendet, weil, wie ich zuvor geschrieben habe, "Nach 200 Minuten sterben die Temperatur nicht kontrolliert sein, soll die Abgerechnet werden müssen" und dann Minuten gleich 200 wären

public class pruv
{
    public int abkuehlung(double atemp, double ztemp, double wtemp) {
        double tee=atemp;
        int min=0;
        double faktor=0.8;
        double temp = (tee - ztemp) * faktor + ztemp;
        while (temp > wtemp) {
            tee=temp;
            min = min+1;
            temp =(tee - ztemp) * faktor + ztemp;
            temp=Math.ceil(temp*100)/100d;
    }

        if (tee> wtemp && min==200) {
        min=200;
        return min;
        }
        return min;
    }

}

 

[kneitzel]

Du hast doch schon den richtigen Rechnungsweg.

Alles, was Du in der Schleife mit prüfen musst, ist die Zeit, denn nach 200 Minuten sollst Du abbrechen.

(Und die ganzen Erläuterungen und Verkomplizierungen fand ich extrem kontraproduktiv. Der Rechenweg war ja vorgegeben und es ging nur darum, dies zu berechnen.)

public int abkuehlung(final double anfangsTemperatur, final double zielTemperatur, final double zimmerTemperatur) {
    int zeit = 0;
    double temperatur = anfangsTemperatur;
    while (temperatur > zielTemperatur && zeit < 200) {
        zeit++;
        double differenz = temperatur - zimmerTemperatur;
        temperatur -= differenz / 5;       
    }
    return zeit;
}

Das wäre also 1:1 ein Code, der aus der Aufgabenbeschreibung abzulesen gewesen wäre.

Daher war die Idee: Spiel es doch einfach einmal von Hand etwas durch, so dass Du die Schleife erkennst.

Da ist noch nicht einmal eine Formel auf einer Zeile zu bilden. Das kann man machen, aber ist ebenfalls unnötig. Und in der Schule / Studium wird es ggf. sowas wie Prüfungen geben - da würde ich unnötige Fehlerquellen durchaus eliminieren... Vor allem, wenn man so Code direkt schreiben soll und nicht am Computer schreibt und dann im Detail testen kann. (Der Code oben ist eben so in dem Editor des Forums entstanden ...)

 

[ImmerDieseKinder]

, wenn die gewünschte Temperatur und die Zimmertemperatur gleich sind, wird die Schleife niemals enden.

Dann solltest du das vorher Abfragen... zum Beispiel so:

    private static double minuten(double umgebungstemperatur, double starttemperatur, double wunschtemperatur, double temperaturAktuell, double minutenAktuell, double temperaturfaktor, double minutenfaktor) {
        double temp = (temperaturAktuell - umgebungstemperatur) * temperaturfaktor + umgebungstemperatur;
        while (temp >= wunschtemperatur) {
            temperaturAktuell = temp;
            minutenAktuell += minutenfaktor;
            temp = (temperaturAktuell - umgebungstemperatur) * temperaturfaktor + umgebungstemperatur;
        }

        if (temperaturAktuell - wunschtemperatur > 1.0e-3) {
            return minuten(umgebungstemperatur, starttemperatur, wunschtemperatur, temperaturAktuell, minutenAktuell, Math.pow(temperaturfaktor, 1.0 / 10.0), minutenfaktor / 10);
        }

        return Math.round(minutenAktuell * 1.0e+4) / 1.0e+4;
    }

    public static double teeminuten(double umgebungstemperatur, double starttemperatur, double wunschtemperatur, double temperaturfaktor) {
        if (wunschtemperatur <= umgebungstemperatur)
            throw new IllegalArgumentException();
        return minuten(umgebungstemperatur, starttemperatur, wunschtemperatur, starttemperatur, 0, temperaturfaktor, 1);
    }

    public static void main(String[] args) {
        System.out.println(teeminuten(20, 90, 35, 0.8));
        System.out.println(teeminuten(0, 100, 80, 0.8));
    }

(Und den Variablen sprechende Namen vergeben)
Das ist jetzt auf 4 Nachkommastellen genau...

 

[kneitzel]

wenn die gewünschte Temperatur und die Zimmertemperatur gleich sind, wird die Schleife niemals enden

Nur noch einmal kurz als klare Aussage: Da ist keinerlei Prüfung notwendig. Der Algorithmus wird immer enden, denn es ist ein klares Limit angegeben:

Sollte nach 200 Minuten die gewünschte Temperatur nicht erreicht sein, soll die Berechnung abgebrochen werden.

Daher immer die Anforderungen im Auge behalten und wirklich die Anforderung umsetzen. Das, was da verlangt wurde, ist relativ simpel und einfach und genau das sollte umgesetzt werden.