pow(Basis, Exponent)

[klaus_kraemer]

Ich habe gerade ewig viele Fehlerereignisse gefunden, die darauf zurückzuführen sind, dass die Basis von pow(Basis,Exponent) nicht negativ sein darf. Das habe ich aber erst jetzt gelesen - im Kleingedruckten sozusagen.

Wie gibt's denn das? pow(-1,3) war doch immer schon -1, weshalb nicht im eibPC?

[klaus_kraemer]

Habt Ihr das eigentlich schon gefixt?

Eine negative Basis einfach nicht zu berechnen ist einfach schwach und Euch als Ingenieuren müssten doch die Haare zu Berge stehen - außer bei 'ner Glatze...

[enertegus]

Eine negative Basis einfach nicht zu berechnen ist einfach schwach und Euch als Ingenieuren müssten doch die Haare zu Berge stehen - außer bei 'ner Glatze...

Wenn man beliebige Exponenten zulässt, wird schon mal an anderer Stelle mathematisch schwierig, egal ob nun mit oder ohne Haare, man denke an (-2)^(1/2). Ich denke - aus der Hüfte geschossen- , das wird auch die zugrunde liegende C-Lib so sehen...

[klaus_kraemer]

Wenn man beliebige Exponenten zulässt, wird schon mal an anderer Stelle mathematisch schwierig, egal ob nun mit oder ohne Haare, man denke an (-2)^(1/2). Ich denke - aus der Hüfte geschossen- , das wird auch die zugrunde liegende C-Lib so sehen...

Sorry, war gerade im fremdsprachigen Ausland unterwegs...

Wer spricht denn gleich von komplexen Zahlen? Aber eine ganzrationale Funktion n-ten Grades sollte dennoch komplett berechnet werden. Hier solltet Ihr dann schon noch einmal nachbessern. Wenn tatsächlich die (gerade) Wurzel einer negativen Zahl berechnet werden sollte, könnt ihr ja immer noch die "Null" als Ergebnis geben - oder von mir aus generell bei Wurzeln aus negativen Zahlen. Aber wie gesagt, eine ganzrationale Funktion muss schon zuverlässig berechnet werden.

[enertegus]

Aber eine ganzrationale Funktion n-ten Grades sollte dennoch komplett berechnet werden.

Ich glaube die Mathematik ist diesbezüglich eindeutig:
Potenz (Mathematik) ? Wikipedia

Die Definition lässt sich nicht auf den Fall erweitern, da in diesem Fall der Grenzwert nicht zu existieren braucht bzw. für verschiedene Wahlen der Folge sich verschiedene Grenzwerte ergeben.

[klaus_kraemer]

Einspruch, Euer Ehren!

So lange der Exponent ganzzahlig ist, liefert pow() in c++ genau das erwartete Ergebnis für negative Basen - und nicht einfach eine "0".

Ich programmiere zwar kein c++, aber Google zeigt genügend Beispiele. Sicher wird auch c++ entsprechende Mechanismen à là try{..} catch{..} zur Verfügung stellen, dass Ihr im Falle ungültiger Parameter den Wert "0" ausgeben könnt.

[enertegus]

So lange der Exponent ganzzahlig ist

Ist er aber nicht. Der Exponent ist allgemein rational.

[klaus_kraemer]

... und die ganzen Zahlen sind eine Teilmenge der rationalen Zahlen, wenn ich mich recht erinnere?

Link: http://en.cppreference.com/w/cpp/numeric/math/pow

"Example

Run this code

(lässt sich leider im Forum schlecht formatieren, bei Interesse, folge bitte dem Link oben)

#include <iostream>
#include <cmath>
#include <cerrno> #include <cfenv>
#include <cstring> 
#pragma STDC FENV_ACCESS ON

int main() {     // typical usage
[URL="http://en.cppreference.com/w/cpp/io/basic_ostream"]std::cout[/URL] << "pow(2, 10) = " << std::pow(2,10) << '\n'               << "pow(2, 0.5) = " << std::pow(2,0.5) << '\n'               << "pow(-2, -3) = " << std::pow(-2,-3) << '\n';     // special values     [URL="http://en.cppreference.com/w/cpp/io/basic_ostream"]std::cout[/URL] << "pow(-1, NAN) = " << std::pow(-1,[URL="http://en.cppreference.com/w/cpp/numeric/math/NAN"]NAN[/URL]) << '\n'               << "pow(+1, NAN) = " << std::pow(+1,[URL="http://en.cppreference.com/w/cpp/numeric/math/NAN"]NAN[/URL]) << '\n'               << "pow(INFINITY, 2) = " << std::pow([URL="http://en.cppreference.com/w/cpp/numeric/math/INFINITY"]INFINITY[/URL], 2) << '\n'               << "pow(INFINITY, -1) = " << std::pow([URL="http://en.cppreference.com/w/cpp/numeric/math/INFINITY"]INFINITY[/URL], -1) << '\n';     // error handling      errno = 0; [URL="http://en.cppreference.com/w/cpp/numeric/fenv/fecrearexcept"]std::feclearexcept[/URL]([URL="http://en.cppreference.com/w/cpp/numeric/fenv/FE_exceptions"]FE_ALL_EXCEPT[/URL]);     [URL="http://en.cppreference.com/w/cpp/io/basic_ostream"]std::cout[/URL] << "pow(-1, 1/3) = " << std::pow(-1, 1.0/3) << '\n';     if(errno == [URL="http://en.cppreference.com/w/cpp/error/errno_macros"]EDOM[/URL]) [URL="http://en.cppreference.com/w/cpp/io/basic_ostream"]std::cout[/URL] << "    errno == EDOM " << [URL="http://en.cppreference.com/w/cpp/string/byte/strerror"]std::strerror[/URL](errno) << '\n';     if([URL="http://en.cppreference.com/w/cpp/numeric/fenv/fetestexcept"]std::fetestexcept[/URL]([URL="http://en.cppreference.com/w/cpp/numeric/fenv/FE_exceptions"]FE_INVALID[/URL])) [URL="http://en.cppreference.com/w/cpp/io/basic_ostream"]std::cout[/URL] << "    FE_INVALID raised\n";       [URL="http://en.cppreference.com/w/cpp/numeric/fenv/fecrearexcept"]std::feclearexcept[/URL]([URL="http://en.cppreference.com/w/cpp/numeric/fenv/FE_exceptions"]FE_ALL_EXCEPT[/URL]);     [URL="http://en.cppreference.com/w/cpp/io/basic_ostream"]std::cout[/URL] << "pow(-0, -3) = " << std::pow(-0.0, -3) << '\n';     if([URL="http://en.cppreference.com/w/cpp/numeric/fenv/fetestexcept"]std::fetestexcept[/URL]([URL="http://en.cppreference.com/w/cpp/numeric/fenv/FE_exceptions"]FE_DIVBYZERO[/URL])) [URL="http://en.cppreference.com/w/cpp/io/basic_ostream"]std::cout[/URL] << "    FE_DIVBYZERO raised\n"; }

Possible output:

pow(2, 10) = 1024
pow(2, 0.5) = 1.41421
pow(-2, -3) = -0.125
pow(-1, NAN) = nan
pow(+1, NAN) = 1
pow(INFINITY, 2) = inf
pow(INFINITY, -1) = 0
pow(-1, 1/3) = -nan errno == EDOM Numerical argument out of domain FE_INVALID raised
pow(-0, -3) = -inf FE_DIVBYZERO raised

[enertegus]

... und die ganzen Zahlen sind eine Teilmenge der rationalen Zahlen, wenn ich mich recht erinnere?

richtig, aber dann müsste man die Definitionsmenge einschränken.
Warum baust Du dir nicht einfach ein Makro?

[klaus_kraemer]

richtig, aber dann müsste man die Definitionsmenge einschränken.
Warum baust Du dir nicht einfach ein Makro?

Na, was denkst Du, wie ich mir geholfen habe?

Ich denke nur, dass eine native Funktion den EibPC weniger belasten wird, als für eine Funktion 5-ten Grades fünf Makros aufzurufen, in denen jedes Mal zusätzlich geprüft wird, ob die Basis negativ und der Exponent ungerade ist, um dann das Ergebnis von pow(abs(t),exp) ggf. noch mit -1 zu multiplizieren... (Ist halt ein wenig viel: Vergleich, Variable setzen, abs()-Funktion, dann erst pow() und wieder multiplizieren mit Vorzeichen)

Hintergrund ist, ich habe mir die Vorlauftemperaturkurve der Fussbodenheizung in Abhängigkeit von der Außentemperatur aus Stützpunkten zusammengesetzt und die Näherungsfunktion bestimmt (Excel gibt das ja ganz einfach her). Nun hat das Ding (pow()) bei negativen Außentemperaturen natürlich ziemlichen Schrott geliefert. In diesem Herbst möchte ich die Regelung vom PC (ohne Eib) auf den EibPC übernehmen...

Auch wenn ich Dich, so wie es aus dem Thread ersichtich ist, wohl nicht überzeugen kann, den Umfang der nativen c++ pow()-Funktion zur Verfügung zu stellen - ich bin ausnahmsweise(!!!) mal ein wenig enttäuscht...

[enertegus]

der nativen c++ pow()-Funktion zur Verfügung zu stellen

der EibPC ist nativ C.
Als ich seinerzeit exp und pow in das Featureheft aufgenommen habe, haben mich hier alle für verrückt erklärt und nun möchte man noch eine pow-Funktion, die speziellle natürliche Exponenten verarbeitet

[Uwe!]

Hintergrund ist, ich habe mir die Vorlauftemperaturkurve der Fussbodenheizung in Abhängigkeit von der Außentemperatur aus Stützpunkten zusammengesetzt und die Näherungsfunktion bestimmt (Excel gibt das ja ganz einfach her). Nun hat das Ding (pow()) bei negativen Außentemperaturen natürlich ziemlichen Schrott geliefert. In diesem Herbst möchte ich die Regelung vom PC (ohne Eib) auf den EibPC übernehmen...

Wärs da nicht einfach in Kelvin statt in Celsius zu rechnen?

[klaus_kraemer]

Sympathische Idee - ich werd's mal testen. Danke!

Bisher läuft die Steuerung der FBH auf dem EibPC nur im Blindbetrieb parallel zu der Steuerung auf dem PC, da war es natürlich einfach, die Funktion 1:1 zu übertragen - bis ich auf den Käse mit den negativen Basen gestoßen wurde...