Verwandte Themen

Frage
von Jensek81
19.02.2024, 22:29
Wärmekapazität und latente Wärme?

Die Zeit läuft davon...

Aufgabe:

"In einem Glas befinden sich 0.5 Liter Wasser bei einer Temperatur von T2 = 20◦C. a) Wieviel Wärme muss dem Wasser entzogen werden, um es auf die Temperatur T1 = 5◦C abzukühlen?
Hinweis für flüßiges Wasser beträgt die spezifische Wärmekapazität c_Wasser = 4.2 Jg−1K−1 . Die Dichte beträgt ρWasser = 1.0 cm−3 .

(b) In das Wasserglas aus (a) bei der Temperatur T2 = 20◦C wird ein Eiswurfel der ¨ Temperatur T0 = −18◦C gegeben. Wie groß muss die Masse des Eiswurfels ¨ mEis (gemessen in g) sein, damit nach dem vollständigen Schmelzen die Temperatur des Wassers gerade T1 = 5◦C beträgt? (Gib den berechneten Wert gerundet auf drei signifikante Stellen an.)

Hinweis: Spezifische Wärmekapazität von Eis: cEis = 2.0 Jg−1K−1 . Schmelzwärme: ∆QS = 333.5 Jg−1 . Schmelztemperatur: TS = 0◦C."

Jensek81'scher Ansatz:
a) 0, 5l = 500 cm³ = 0, 5 dm³ = 0,5 * 10^-3 m
m*p* V = 1,0 g /cm³ * 0,5 * 10^-3 m³ = 500 g

Temperaturveränderung ∆ T = T2 - T1 = 20 Grad -- 5 Grad = 15 Grad

∆Q = cw * mw * ∆T = 5,2 J / g C * 500 g * 15 C = 31500 J

b) Zunächst wird das EIs von -18 Grad au f0 Graad erwämt. Dazu wird Wärme Q1 benötigt.

Q1 = m * c * ∆T = 2,0 J/kgK * 18 Grad = 36 kJ/kg
Dann wird Eis geschmolzen. Dazu Wärme Q2

Q2 = m * q = m * 335, Jg^-1
Um das geschmolzene Wasser auf 5 Grad zu erwärmen ist Q3 erforderlich.

Q3 = m * c * ∆T = m * 4,2 Jg^-1/K^^1 * 5 K = m * 21 kJ/Kg

Q = Q1 + Q2 + Q3

m * 36 kJ/kg + m * 333,5 kJ/Kg + m * 21 kJ/kg = 31500 J
m (36 kJ/Kg + 333,35 kj/kg + 21kJ/Kg) = 31500 J
m + 390,5 kJ/kg = 31500 J

=> m = 31500 J/ 390,5 kJ/g = 80,66 g

Der Eiswrüfel hat 80,66 g

Kann das sein? oder ist das Kakolores?

Mit freundlichen Grüßen.
Ach, jetzt hätt ich schon fast ausversehen meinen Klarnamen geschrieben.
Seht ihr, soweit kommt's noch. Hahaha
Also, nochmal:
Mit freundlichen Grüßen,
Jensek81

Wasser, Mathematik, Temperatur, Eis, rechnen, denken, Wärme, Eiswürfel, Experimentalphysik, Physik, Thermodynamik, Wärmelehre, Kapazität, addieren
1 Antwort
Frage
von rixtwix007
18.02.2024, 17:08
C++ Code für LGS?

Ich möchte mit einen C++-Programm alle LGS lösen können (endlich, unendlich und keine Lösungen). Ich habe auch einen Code. Endlich viele und keine Lösungen kann er recht gut (bisher), aber unendlich viele Lösungen kann er nicht anzeigen lassen (soll dann auch t einführen, nicht einfach einen Wert einsetzen).

Wo liegt der Fehler?

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

// Funktion zur Berechnung des Determinanten einer Matrix
double determinant(vector<vector<double>>& matrix, int n) {
  double det = 0;

  if (n == 1) {
    return matrix[0][0];
  }

  if (n == 2) {
    return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
  }

  for (int i = 0; i < n; i++) {
    vector<vector<double>> subMatrix(n - 1, vector<double>(n - 1));

    for (int j = 1; j < n; j++) {
      for (int k = 0; k < n; k++) {
        if (k < i) {
          subMatrix[j - 1][k] = matrix[j][k];
        }
        else if (k > i) {
          subMatrix[j - 1][k - 1] = matrix[j][k];
        }
      }
    }

    det += pow(-1, i) * matrix[0][i] * determinant(subMatrix, n - 1);
  }

  return det;
}
 
// Funktion zur Durchführung der Gauss-Jordan-Elimination
void gaussJordan(vector<vector<double>>& matrix, vector<double>& constants) {
  int n = matrix.size();

  for (int i = 0; i < n; i++) {
    int maxIndex = i;

    for (int j = i + 1; j < n; j++) {
      if (abs(matrix[j][i]) > abs(matrix[maxIndex][i])) {
        maxIndex = j;
      }
    }

    if (maxIndex != i) {
      swap(matrix[maxIndex], matrix[i]);
      swap(constants[i], constants[maxIndex]); // Korrektur hier
    }

    double factor = matrix[i][i];

    for (int j = i; j < n; j++) {
      matrix[i][j] /= factor;
    }

    constants[i] /= factor;

    for (int j = 0; j < n; j++) {
      if (j != i) {
        double factor = matrix[j][i];

        for (int k = i; k < n; k++) {
          matrix[j][k] -= factor * matrix[i][k];
        }

        constants[j] -= factor * constants[i];
      }
    }
  }
}

// Funktion zur Überprüfung der Invertierbarkeit und zur Lösung des LGS
vector<double> solveLinearSystem(vector<vector<double>>& matrix, vector<double>& constants) {
  int n = matrix.size();
  double det = determinant(matrix, n);

  // Überprüfung auf unendlich viele Lösungen
  bool allZero = true;

  for (double constant : constants) {
    if (constant != 0) {
      allZero = false;
      break;
    }
  }

  if (det == 0) {
    if (allZero) {
      cout << "Das LGS hat unendlich viele Lösungen." << endl;
      return {}; // Leerer Vektor, da unendlich viele Lösungen existieren
    }
    else {
      cout << "Das LGS hat keine Lösung." << endl;
      return {}; // Leerer Vektor, da keine Lösung existiert
    }
  }

  // Anwendung der Gauss-Jordan-Elimination
  gaussJordan(matrix, constants);

  vector<double> solution(n);

  for (int i = 0; i < n; i++) {
    solution[i] = constants[i];
  }

  return solution;
}

int main() {
  vector<vector<double>> matrix = {
    { 1, -3,  5 },
    { 2, -5,  12 },
    { 3, -11,  11 }
  };
  vector<double> constants = { 2, 1, 12 };

  vector<double> solution = solveLinearSystem(matrix, constants);

  if (!solution.empty()) {
    cout << "Die Lösung des LGS ist: ";

    for (int i = 0; i < solution.size(); i++) {
      cout << "x" << i + 1 << " = " << solution[i] << ", ";
    }

    cout << endl;
  }
  else {
    cout << "Das LGS hat keine Lösung." << endl;
  }

  return 0;
}
Schule, Mathematik, programmieren, Cplusplus, Mathematiker, Programmiersprache, Algorithmus, lineare Gleichungssysteme
1 Antwort

Meistgelesene Fragen zum Thema Mathematik
Mehr meistgelesene Fragen zu Mathematik