Logarithmische Translation umkehren

16.06.2017, 23:17

Achromat

Logarithmische Translation umkehren

Meine Frage:
Guten Tagchen

ich als Programmierer verwende die Logarithmische Transformation um einen großen Wertebereich anfänglich mit einem Schieber langsam zu steigern bis der wert exponentiell ansteigt und sein Maximum schnell erreicht.

Dafür verwende ich den unten stehenden Rechengang um einen Schieber Bereich von 0.01 - 2Sekunden zu verwenden um eine Belichtungszeit in Mikrosekunden auszudrücken. der maximal Wert ist also 2million mikrosekunden.

LogInterFromPosition(Stellwert 0.5[s] , maximalStellwert 2.0[s],MinimalStellwert 0.01[s], Skalierziel MinimalWert 1[µS], MaximalWert 2000000[µS])

Das klappt wunderbar, und man effektiv regeln, aber wie bekomme ich aus dem Skalierziel Bereich 1-200000 wieder den Stellwert zurück. Das würde ich mal gerne wissen.. Vielen Dank für Hinweise Karsten aus Berlin

Meine Ideen:
__inline double CCamOpt::LogInterFromPosition(double x, double minIn, double maxIn, double dmax, double dmin)
{
double v((log(dmax) - log(dmin)) / (maxIn - minIn));
double n((minIn * log(dmax) - maxIn * log(dmin)) / (log(dmax) - log(dmin)));
return exp(v * (x - n)); //logarithmische translation (Kehrwert unklar)
}

16.06.2017, 23:27

HAL 9000

Auf diesen Beitrag antworten »

D.h., du willst einfach nur Gleichung $\begin{align*} y=\exp(v(x-n)) \end{align*}$ nach $\begin{align*} x \end{align*}$ umstellen? Wo genau klemmt es denn da?

17.06.2017, 01:05

Achromat

Auf diesen Beitrag antworten »

Ja das wäre toll, ich bin leider etwas rückständig mit den Rechenregeln, wie würde denn das Äqualen aussehen , das nach dem Eingangswert x(Stellwert) umstellt.
Und das geht trotz der logarithmischen Interpolation ?

Ich bin etwas aus der Übung wie mir scheint nach 40 Jahren Schulentzug smile

Aber umstellen so wie Du gesagt hast wäre schon schön..

Leider klappt es nicht, ich habe versucht die Kurve zu spiegeln und zu drehen aber schwierig bleibts den stellwert bekomme ich nicht mehr raus leider ...
Könntest Du mir da helfen ?

Online umstellter versagen mit meiner programmierstyle Notifikation..

(Oh mein Gott es ist voller Sterne)

17.06.2017, 07:34

HAL 9000

Auf diesen Beitrag antworten »

Von außen nach innen vorarbeiten:

$\begin{align*} \log(y) &= v(x-n) \end{align*}$

$\begin{align*} \frac{1}{v}\log(y) &= x-n \end{align*}$

$\begin{align*} \frac{1}{v}\log(y)+n &= x \end{align*}$ ,

und das mit den Werten $\begin{align*} v=\frac{\log(d_{\max})-\log(d_{\min})}{\max_{In}-\min_{In}} \end{align*}$ sowie $\begin{align*} n=\frac{\min_{In}\log(d_{\max})-\max_{In}\log(d_{\min})}{\log(d_{\max})-\log(d_{\min})} \end{align*}$ von oben.

Ein Kommentar hinsichtlich des Rechenaufwands zu den Formeln $\begin{align*} y=\exp(v(x-n)) \end{align*}$ bzw. $\begin{align*} x = \frac{1}{v}\log(y)+n \end{align*}$ : Die sind einigermaßen effizient, wenn man die Koeffizienten $\begin{align*} v \end{align*}$ und $\begin{align*} n \end{align*}$ vorberechnet, d.h., nur einmal bestimmt und dann für viele $\begin{align*} x \end{align*}$ oder $\begin{align*} y \end{align*}$ anwendet.

Wenn es aber so wie oben geschieht, d.h., für jedes einzelne $\begin{align*} x \end{align*}$ erneut zu berechnen, dann sind folgende Darstellungen weniger rechenaufwändig:

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

__inline double CCamOpt::LogInterFromPosition(double x, double minIn, double maxIn, double dmax, double dmin)
{
	double ldmin = log(dmin);
	return exp((log(dmax) - ldmin) / (maxIn - minIn) * (x - minIn) + ldmin);
}

__inline double CCamOpt::InvLogInterFromPosition(double y, double minIn, double maxIn, double dmax, double dmin)
{
	double ldmin = log(dmin);
	return (maxIn - minIn) / (log(dmax) - ldmin) * (log(y) - ldmin) +  minIn;
}

Möglicherweise muss das mit der Extrazeile "ldmin = log(dmin)" auch gar nicht sein - moderne Compiler erkennen, dass log(dmin) nur einmal berechnet werden muss und optimieren das auch so ganz gut raus.

Aber wie gesagt: Vorberechnung von $\begin{align*} v,n \end{align*}$ wäre der viel bessere Weg bei vielen $\begin{align*} x,y \end{align*}$ . In der Regel sind $\begin{align*} \log \end{align*}$ und $\begin{align*} \exp \end{align*}$ ja deutlich teurer als die Grundrechenarten, man sollte also die Häufigkeit ihrer Aufrufe auf das notwendige Minimum beschränken.

17.06.2017, 14:25

Achromat

Auf diesen Beitrag antworten »

Es ist voller Sterne
Hal, Mensch..

Jetzt habe ich das integriert:
Das ist ja genial, das funktioniert sehr präzise.

Ich mache ja selber auch irre Rechengänge, aber ich folge keinen Regeln,
es entstand sogar eine eigene Form der Zahlenwahrnehmung.

Aber das mit Regeln wieder auf den Urwert bringen, ist eine Leistung
die nur durch akribische Gesetzeskunde hervorzubringen ist.

Das ist sehr Bewundernswert, so einen HAL zu haben wäre schon schön smile

Ich habe mir damit nun noch ein anderes Problem eingehandelt das ich
erst mal verstehen muss, die Belichtungszeit kann ich nun also wieder einer
Schieberposition zuordnen das ist erstmal sehr aufregend.

Wird auch in den Sourcen erwähnt das HAL die Aufgabe löste.
Das bleibt sicher nicht unbemerkt.

Die besten Grüße aus Preußen
Karsten
FlexxVision.de

18.06.2017, 01:56

Achromat

Auf diesen Beitrag antworten »

Nachmessung
Gegentest erfolgreich

code:

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:

#include "stdio.h"
#include "math.h"

__inline double LogInterFromPosition(double x, double minIn, double maxIn, double dmax, double dmin)
{
	double ldmin = log(dmin);
	return exp((log(dmax) - ldmin) / (maxIn - minIn) * (x - minIn) + ldmin);
}

__inline double InvLogInterFromPosition(double y, double minIn, double maxIn, double dmax, double dmin)
{
	double ldmin = log(dmin);
	return (maxIn - minIn) / (log(dmax) - ldmin) * (log(y) - ldmin) +minIn;
}

int main()
{
	for (float x = 0.01; x < 2.0; x = x + 0.1)
	{
		double minsec = 0.01;//0.10Sek=10ms
		double maxsec = 2.00;//2Sek
		double maxval = 2000000;//2Sek = 2 Milionen mikrosekunden
		double minval = 1;//100 Mikrosekunden

		//logorythmischetranslation von Sekunden nach Mikrosekunden
		double v1 = LogInterFromPosition(x, minsec, maxsec, maxval, minval);

		//logorythmischetranslation umkehren von Mikrosekunden nach Sekunden um einen deckungsgleichen Stellwerte aus dem istwert(mikrosekunden) zu erlangen
		double v2 = InvLogInterFromPosition(v1, minsec, maxsec, maxval, minval);

		printf("Stellwert=%f  ExpLogStellWert=%f Kehrwert=%f\r\n", x, v1, v2);
	}

    return 0;
}

18.06.2017, 09:52

HAL 9000

Auf diesen Beitrag antworten »

Deine Begeisterung in allen Ehren, aber mach das Thema nun nicht aufregender als es ist:

Zwischen Einstellwert In (im Bereich $\begin{align*} \min\nolimits_{In} \end{align*}$ bis $\begin{align*} \max\nolimits_{In} \end{align*}$ ) und dem Logarithmus des Ausgangswerts $\begin{align*} d \end{align*}$ (im Bereich $\begin{align*} d_{\min} \end{align*}$ bis $\begin{align*} d_{\max} \end{align*}$ ) herrscht ein linearer Zusammenhang. D.h., es geht abgesehen von dieser äußeren Transformation $\begin{align*} \exp,\log \end{align*}$ de facto nur um eine einfache Geradengleichung, die die beiden Punkte $\begin{align*} (\min\nolimits_{In},\log(d_{\min})) \end{align*}$ und $\begin{align*} (\max\nolimits_{In},\log(d_{\max})) \end{align*}$ miteinander verbindet.

Zitat:

Original von Achromat
Wird auch in den Sourcen erwähnt das HAL die Aufgabe löste.
Das bleibt sicher nicht unbemerkt.

Da kann ich mir ein Lachen nicht verkneifen. Wenn du in den Sourcen erwähnst, dass du dir mit Hilfe des Matheboards ein wenig Klarheit über diese Transformation verschafft hast, ist es auch gut. smile

18.06.2017, 11:28

Achromat

Auf diesen Beitrag antworten »

Es sind gerade die einfachen Dinge die nicht offenbar werden konnten.

Neue Frage »

Antworten »

Logarithmische Translation umkehren

Verwandte Themen