"Beethovens großer Durchbruch" vermute ich.

https://www.moviepilot.de/movies/beethovens-groer-durchbruch

Weil (- 1) ^ 3 = - 1 ist.

https://elearning.physik.uni-frankfurt.de/data/FB13-PhysikOnline/lm_data/lm_281/modul_2/teil_5/node51.html

Ja, dafür gibt es eine Iterationsformel :

Wenn du nicht weißt was eine Iteration ist, dann schaue bitte im Internet nach, auch auf Youtube.

r = (r - r ^ (1 - n)) / (r - 1)

Man hätte als Variablennamen auch x nehmen können, statt r (angelehnt an das Wort "ratio").

Bei der Wahl des Iterationsstartwertes muss man vorsichtig sein, nicht mit jedem Iterationsstartwert konvergiert diese Formel. Beispielsweise mit den Startwerten r = 0 und r = 1 und r = - 1 gibt es keine Konvergenz.

Man kann aber getrost r = 2 als Iterations-Startwert verwenden.

Allerdings --> Je höher n ist, desto langsamer ist die Konvergenz, und desto mehr Iterationen werden benötigt.

Hier mal ein Bild :

Die letzte Spalte kann man als Schätzwert für die Anzahl der Nachkommastellen hernehmem, die zuverlässig sind.

Man sieht auch, dass es insgesamt einen Grenzwert gibt, der gegen 2 strebt.

Online-Banking (Online-Bänking). Habe noch nie gehört, dass es ohne ä ausgesprochen wird. Mit Banker (Bänker) ist es genauso.

(1 / 5) * 20 = 4 blaue Kugeln, das bedeutet 16 nicht-blaue Kugeln.

Grüne Kugeln plus rote Kugeln = 16

Rote Kugeln minus grüne Kugeln = 4

Das bedeutet :

6 grüne Kugeln

10 rote Kugeln

4 blaue Kugeln

Wie groß ist die Wahrscheinlichkeit, genau eine grüne Kugel zu ziehen ?

---------------------------------------------------------------------------------------------------------------------------------------------

Eine Urne / ein Sack enthält N Kugeln, davon haben A Kugeln eine ausgewählte Farbe.

Der Urne / dem Sack werden K Kugeln ohne Zurücklegen entnommen.

Die Wahrscheinlichkeit aus dieser genannten Urne / Sack genau G Kugeln dieser ausgewählten Farbe zu ziehen beträgt →

p = (A über G) * ((N – A) über (K – G)) / (N über K)

Das sind Binomialkoeffizienten und es handelt sich um die hypergeometrische Verteilung.

(Der Buchstabe G hier hat nichts mit grün zu tun.)

Bei deinem Beispiel :

N = 20

A = 6

K = 1 (ich habe es so verstanden, dass nur einmal eine einzige Kugel gezogen wird)

G = 1

Also :

p = (6 über 1) * ((20 - 6) über (1 - 1)) / (20 über 1)

p = 3 / 10 = 0.3

Also beträgt die Wahrscheinlichkeit 30 %

Du wohnst in einer Mietwohnung eines kleinen Mehrfamilienhauses.

Regelmäßig hört du bei den Nachbarn ein Kind schreien und weinen.

Das kümmert dich jedoch nicht, und "in fremde Angelegenheiten mischt man sich nicht ein" ist dein unumstößliches Credo.

Eines Tages steht die Behörde samt Polizei vor Nachbars Tür, es geht um schwere Kindesmisshandlung.

Als man dich fragt, ob du was mitbekommen hast, sagst du "nichts besonderes".

Du hast unterreagiert.

I.) x_1 + 2 * x_2 - x_3 = 4

II.) 2 * x_1 - x_2 - 2 * x_3 = -2

Das sind 2 Gleichungen, aber 3 Unbekannte Variablen.

Deshalb handelt es sich um ein sogenanntes unterbestimmtes Gleichungssystem.

Es können deshalb (3 - 2) = 1 Variablen frei gewählt werden, die anderen beiden Variablen hängen deshalb von der frei gewählten Variablen ab.

Dabei spielt es meistens / oftmals keine Rolle, welche der Variablen man als frei Wählbar wählt, deshalb gibt es mehrere Möglichkeiten.

Es ist aber häufig üblich, die Variablen mit dem kleinsten Index als frei wählbar zu wählen. Man rechnet dann von "hinten nach vorne", stellt also zunächst nach der Variablen mit dem höchsten Index um, danach nach der mit dem zweithöchsten Index und so weiter.

Bei der freien Wählbarkeit kann es Einschränkungen geben, zum Beispiel, dass bestimmte Werte nicht erlaubt sind, weil es sonst zur Division mit Null kommt u.ä., dass muss man dann extra mit bei schreiben; kommt aber in deinem Beispiel nicht vor.

I.) x_1 + 2 * x_2 - x_3 = 4

II.) 2 * x_1 - x_2 - 2 * x_3 = -2

I.) nach x_3 auflösen :

I.) x_3 = x_1 + 2 * x_2 - 4

x_3 in II.) einsetzen :

II.) 2 * x_1 - x_2 - 2 * (x_1 + 2 * x_2 - 4) = -2

II.) nach x_2 auflösen :

II.) x_2 = 2

x_2 in die Gleichung für x_3 einsetzen :

I.) x_3 = x_1 + 2 * 2 - 4 = x_1

Fazit :

x_1 = frei wählbar

x_2 = 2

x_3 = x_1

Ich würde folgendes Modell nehmen

f(x) = (x + a) / (x - 1)² + 0.5 * x

Dann muss gelten :

(2 + a) / (2 - 1) ^ 2 + 0.5 * 2 = 0

Das ist für a = - 3 erfüllt.

Also :

f(x) = (x - 3) / (x - 1)² + 0.5 * x

Wahrscheinlichkeit = Anzahl der günstigen Ereignisse / Anzahl aller Ereignisse

Anzahl aller Ereignisse in deinem Beispiel = 20

a.)

4, 8, 12, 16, 20

Das sind 5 günstige Ereignisse.

p = 5 / 20 = 0.25

Also 25 %

b.)

15, 16, 17, 18, 19, 20

Das sind 6 günstige Ereignisse.

p = 6 / 20 = 0.3

Also 30 %

c.)

Nur die Zahl 20 ist, von den Zahlen 1 bis 20, durch 5 und 4 teilbar.

Das ist 1 günstiges Ereignis.

p = 1 / 20 = 0.05

Also 5 %

Folgende -->

Numerische Mathematik, Hans Rudolf Schwarz, Teubner Verlag

Mathematik Computer-Lösungen schnell trainiert, Rainer und Patrick Gaitzsch, mvg Verlag (Moderne Verlagsgesellschaft) (ist nur noch gebraucht zu haben)

Numerische Mathematik - 40 BASIC-Programme, Dietmar Herrmann, Vieweg Verlag

Wahrscheinlichkeitsrechnung und Statistik — 30 BASIC-Programme, Dietmar Herrmann, Vieweg Verlag

Basic-Programme zur Numerischen Mathematik, Jürgen Kahmann, Vieweg+Teubner Verlag

Stochastik, Arthur Engel, Klett - Verlag (ist nur noch gebraucht zu haben)

https://de.wikipedia.org/wiki/Arthur_Engel

Formelsammlung zur numerischen Mathematik mit BASIC-Programmen, Gisela Engeln - Müllges , Fritz Reutter, BI Wissenschaftsverlag

Formelsammlung zur numerischen Mathematik mit Quick Basic-Programmen, Gisela Engeln - Müllges , Fritz Reutter, BI Wissenschaftsverlag

Numerische Mathematik für Ingenieure, Gisela Engeln - Müllges , Fritz Reutter, BI Wissenschaftsverlag

Numerische Verfahren der Programmiertechnik (Kompendium der Programmiertechnik), Gerhard Paulin, Eberhard Griepentrog, Verlag Technik

Programmiersprache ALGOL 60

(antiquarisch zu haben)

In dem Buch wird unter anderen die Determinantenberechnung mit und ohne Zerstörung des Feldes gezeigt.

Astronomie mit dem Personal Computer, Oliver Montenbruch, Thomas Pfleger

Die Version von 1989 enthält Programme in der Programmiersprache PASCAL -->

https://www.springer.com/de/book/9783662058640

Es gibt ein moderneres Buch mit C++ - Programmen stattdessen.

In dem gibt es unter anderem ein brauchbares Unterprogramm, welches überbestimmte lineare Gleichungssysteme, berechnen kann. Das kann man auch als Grundlage für Curve-Fitting nehmen, wenn man es mit der Jacobi-Matrix "füttert".

Numerische Behandlung partieller Differentialgleichungen, Th. Meis, U. Marcowitz, Springer - Verlag

(enthält FORTRAN-Programme welche nicht schwer nach BASIC zu übersetzen sind). Da ich im Privatleben nichts mit partiellen Differentialgleichungen zu tun habe, habe ich jedoch keinen wirklichen Nutzen aus dem Buch ziehen können.

Die Theorie in dem Buch ist schwer zu verstehen, manche Dinge konnte ich verstehen.

Anmerkungen :

• Viele dieser Autoren haben mehr als nur ein brauchbares Buch herausgebracht
• Manche Bücher sind nur noch gebraucht übers Internet zu haben.
• Die Programmiersprache ist meinstens BASIC, wenn ich nicht was anderes geschrieben habe, insbesondere QBASIC, QUICKBASIC, welche mit minimalen Anpassungen auch unter QB64 und FreeBASIC laufen. Wenn du eine andere Programmiersprache verwendest, dann sollte es auch nicht übertrieben schwer sein die Programme von BASIC zu einer anderen Programmiersprache zu übersetzen.
• FreeBASIC ist ziemlich modern, und hat einen Kompatibilitätsmodus für das ältere QBASIC.

https://www.portal.qb64.org/

https://www.freebasic.net/

Und hier noch mal eine Sammlung von englisch-sprachigen Büchern, die ich jedoch nicht persönlich durchgearbeitet habe, weil ich inzwischen mehr Programme habe, als ich als Privatperson brauche und weder die Zeit noch die Lust habe so viele Bücher durchzuarbeiten (Die Piratenpartei lässt grüßen, mal ein bisschen Politik am Rande, außerdem soll da noch mal einer behaupten Torrents würden destruktiv nur dazu verschwendet werden Computergames und Extrempornos zu beschaffen, und von ihnen könne nichts positives ausgehen) :

https://www.thepiratebay.org/torrent/12373542/Numerical_analysis_and_methods

Ein anderer User hier auf GF (dessen Name mir leider entfallen ist, Schande über mich ...) hat mich vor längerer Zeit auf diese Webseite aufmerksam gemacht :

http://alvand.basu.ac.ir/~dezfoulian/files/Numericals/Cambridge%20-%20Numerical%20Recipes%20in%20C_%20The%20Art%20of%20Scientific%20Computing,%202nd%20Ed.,%20Press%20W.H.,%20Teukols.pdf

Ich kann auch kein C++, aber ich habe mir mal den Spaß erlaubt ein Programm zusammenzuschustern :

#include <iostream>

#include <math.h>

using namespace std;

int main() {

   double a,b,c,v,o,d;

   cout << "Länge der Seite a ? ";

   cin >> a;

   cout << "Länge der Seite b ? ";

   cin >> b;

   cout << "Länge der Seite c ? ";

   cin >> c;

   v=a*b*c;

   o=2*(a*b+b*c+a*c);

   d=sqrt(pow(a,2)+pow(b,2)+pow(c,2));

   std::cout << "" << std::endl;

   std::cout << "Das Volumen beträgt : " << v << std::endl;

   std::cout << "Die Oberfläche beträgt : " << o << std::endl;

   std::cout << "Die Raumdiagonale beträgt : " << d << std::endl;

   return 0;

   exit(0);

}

Ich habe das Programm online ausprobiert, und zwar hier :

https://www.jdoodle.com/online-compiler-c++

Das C++ dort ist das GCC 8.1.0 und man muss "Interactive mode" auf "On" stellen, damit die Eingaben auf der Webseite funktionieren.

Vielleicht kann man an dem Programm noch einiges optimieren.

pow(a, 2) auf jeden Fall, das kann man auch aus a * a schreiben, aber ich wollte dir auch gleich zeigen, wie der Befehl zum potenzieren lautet.

return 0; und exit(0); wahrscheinlich brauchst du nur eines davon.

Nun zur Programmbeschreibung, weil ich C++ selber nicht kann, kann ich dir das nur sehr primitiv beschreiben :

#include <iostream>

Das importiert die Bibliothek iostream, damit man die Befehle cout und cin verwenden kann.

#include <math.h>

Das importiert die Bibliothek math.h, damit man die Befehle wie Wurzelziehen und potenzieren verwenden kann.

using namespace std;

Ist dazu gedacht um Namenskonflikte zu vermeiden, und bestimmte Variablennamen verwenden zu können, mehr weiß ich dazu auch nicht.

int main() {

}

Hier drin steht das Hauptprogramm / die Hauptfunktion.

double a,b,c,v,o,d;

Definiert die Variablen a,b,c,v,o und d als Variablen mit doppelter Rechengenauigkeit.

cout

Gibt etwas auf dem Bildschirm aus.

cin >> a;

Erwartet eine Eingabe und speichert diese Eingabe dann in die Variable a

sqrt(Argument)

Das berechnet die Quadratwurzel.

pow(a, 2)

Das berechnet a ^ 2, also es wird potenziert.

std::cout << "" << std::endl;

Das gibt lediglich eine Leerzeile auf dem Bildschirm aus, kann man auch abkürzen mit std::cout << std::endl;

std::endl zeigt an, dass die Zeile zu ende ist.

std:: kann ich dir auch nicht richtig erklären, sorry.

return 0; und exit(0); beenden Programme, was der Unterschied ist, und welches davon man wirklich braucht kann ich dir nicht sagen, sorry.

Halbfläche der kleinen Halbkreise :

A = (1 / 2) * pi * (pi / 2) ^ 2 = (1 / 8) * pi ^ 3



(1 / 8) * pi ^ 3 - 2 = 1.875784585 für eine Mondsichel

Bei dem Körper handelt es sich um ein Prisma mit der Grundfläche eines gleichseitigen, regelmäßigen, regulären Sechsecks.

Allgemein gilt beim Prisma folgendes :

V = G * h

Volumen = Grundfläche mal Höhe

Du musst also den Flächeninhalt des gleichseitigen, regelmäßigen, regulären Sechsecks berechnen, dieser Flächeninhalt bildet die Grundfläche des Prismas.

Dafür gibt es eine Formel :

G = (n / 4) * a ^ 2 / tan(180° / n)

Taschenrechner auf Gradmaß stellen !

a = Grundseitenlänge =Grundkantenlänge = Seitenlänge der Grundfläche

Weil es sich um ein Sechseck handelt, ist n = 6

Ganz konkret ausgerechnet :

a = 60 cm

n = 6

h = 60 cm

G = (6 / 4) * 60 ^ 2 / tan(180° / 6) = 9353,074360871939 cm ^ 2

V = G * h

V = 9353.074360871939 * 60 = 561184,4616523163 cm ^ 3

1 cm ^ 3 = 0,000001 m ^ 3

V = 561184,4616523163 cm ^ 3

V = 0,5611844616523163 m ^ 3

Sei gegenüber Menschen stets misstrauisch.

Erwarte am besten rein gar nichts von ihnen, und bereite dich stattdessen darauf vor enttäuscht zu werden, dann machst du nichts falsch.

Umso größer ist dann die Freude, wenn du nicht enttäuscht wirst.

Ich habe Python mal ausprobiert gehabt, aber da mir die Art und Weise wie in Python Arrays indiziert werden nicht gefallen hat, habe ich diese Programmiersprache nicht mehr weiter verfolgt.

Ich hätte da mal eine Gegenfrage, und zwar -->

Was soll dein Programm eigentlich leisten ?

Soll es

(12sin(2)2sin(4)sin(x) + 3sin(8)sin(x) + 12sin(2)sin(x) + 40sin(2)*2sin(4)cos(x) + 10sin(8)cos(x) + 40sin(2)cos(x))/(2(sin(4) + 2*sin(2)))

zu 3 * sin(x) + 10 * cos(x) vereinfachen, oder wie ist das zu verstehen ?

Oder soll das zu 3 * sin(x) + 10 * cos(x) approximiert werden, wobei der Fehler so gering wie möglich zu halten ist ?

Ein Maikäfer hat eine Länge von 25 mm bis 30 mm, und sein Gewicht beträgt zwischen 0,4 bis 0,9 Gramm.

Giraffenhalskäfer erreichen eine Gesamtlänge von 25 mm.

Also wird sich deren Gewicht auch in etwa in dem oben genannten Rahmen bewegen.

https://www.tierchenwelt.de/kaefer/2513-maikaefer.html