Logarithmus nicht als Kommazahl

22.11.2014, 16:39

jankal

Logarithmus nicht als Kommazahl

Meine Frage:
Vorab: Ich möchte mit dem Logarithmus verschlüsseln.

Mein Problem:
Wenn man den Logarithmus mit dem Computer berechnet hat er im Prinzip unendlich viele Nachkommastellen. Aber ich kann unendliche Dinge nur mit einer beschränkten genauigkeit speichern.

$\begin{eqnarray*} log_{10}{(15/12)*12} = 1,162920156 \end{eqnarray*}$
$\begin{eqnarray*} 10^{1,162920156/12}*12 = 15 \end{eqnarray*}$

Nun meine Frage:
Lässt sich der Logarithmus auch irgendwie in einer Beliebig langen Ganzzahl ohn Kommas (diese kann ich für eine Genauigkeit bis zu 4 Mil. Stellen speichern) darstellen?

Meine Ideen:
Mein erster Ansatz war, dem Logarithmus zu berechnen und dann mit $\begin{eqnarray*} 10^{Nachkommastellen} \end{eqnarray*}$ zu multiplizieren. Nur nicht dran gedacht, dass ich die vielen Nachkommastellen trotzdem irgendwo speichern muss.

22.11.2014, 17:54

Dopap

Auf diesen Beitrag antworten »

ich nehme an, dass du damit eine Pseudozufallsziffernfolge erzeugen willst.
Aber Vorsicht: eine solche Folge als Key ist nicht länger ( besser ) wie deren kürzeste Beschreibung, und die ist nun mal der Logarithmus (n) selbst.

Und warum verschlüsselst du nicht sukzessive blockweise so, wie die Ziffern beim Berechnen anfallen ? Dann entfällt das Speichern der evtl. langen ZiffernFolge.

22.11.2014, 18:40

jankal(Gast)

Auf diesen Beitrag antworten »

Logarithmus nicht als Kommazahl
Nein, eigentlich basiert die Verschlüsselung darauf. Der Logarithmus ist sozusagen die Verschlüsselung.

Meine Formel dafür (code in Python):

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:

def generateKey( password ): 
	if((strlen(password) % 2) == 1):
 		password.ljust(strlen(password) + 1) 
	first = password[0:strlen(password)/2]
 	second = password[strlen(password)/2:strlen(password)] 	
        crc1 = crc32(first) 
	crc2 = crc32(second) 	if(crc1 < 0): 		
        crc1 = (crc1 * -1);
  	if(crc2 < 0) :
 		crc2 = (crc2 * -1);
  	result = {"key": crc1, "key2": crc2}
 	return result  

def encrypt(keyarr, text):
 	key = decimal.Decimal(keyarr['key'])
 	key2 = decimal.Decimal(keyarr['key2'])
 	mathlog1 = decimal.Decimal(text) / decimal.Decimal(key)
 	log = log_base(key2, mathlog1) * key
 	encrypted = base64.b64encode(repr(log)) 
	return encrypted  

def decrypt(keyarr, text): 
	key = keyarr['key'] 	
        key2 = keyarr['key2']
 	b64 = base64.b64decode(text)
 	floatb64 = decimal.Decimal(b64[9:strlen(b64)-2])
 	decrypted = math.pow(key2, (floatb64 / key)) * key 
	return long(decrypted)

Reinformel:
$\begin{eqnarray*} log_{10}(input / key)* key = output \end{eqnarray*}$
$\begin{eqnarray*} 10^{output / key}* key = input \end{eqnarray*}$

Problem: output ist eine sehr laaange Fließkommazahl, welche ich nicht genau speichern kann. Somit treten beim entschlüsseln ab einem input von mehr als 24 Stellen ungenauigkeiten auf.

22.11.2014, 19:33

Dopap

Auf diesen Beitrag antworten »

ja, dann solltest du blockweise mit 20 Ziffern einen Input von 10 characters , die vorher in {00,01,03,...,99} abgebildet wurden, verschlüsseln.
Wie bildest du denn den Input-string als Zahl ab ?

Für jeden Block eben einem neuen Key verwenden, oder zumindestens gelegentlich wechseln.

23.11.2014, 11:40

jankal

Auf diesen Beitrag antworten »

Zitat:

Original von Dopap
ja, dann solltest du blockweise mit 20 Ziffern einen Input von 10 characters , die vorher in {00,01,03,...,99} abgebildet wurden, verschlüsseln.
Wie bildest du denn den Input-string als Zahl ab ?

Für jeden Block eben einem neuen Key verwenden, oder zumindestens gelegentlich wechseln.

Mein Input-String ergibt für jeden Buchstaben eine Zahl von 000 - 127 (Umwandlung der Zeichen durch ASCII-Tabelle). Mein aktueller Code:

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:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:

#!/usr/bin/python
import math
import binascii
import base64
import sys
import decimal

decimal.getcontext().prec = 5000

def log_base( b, a ):
	return a.ln() / b.ln()
	#return math.log( decimal.Decimal(a) ) / math.log( decimal.Decimal(b) )

def strlen(x):
   return len(x)

def crc32(x):
	result = binascii.crc32(x) & 0xffffffff
	return result

def generateKey( password ):
	if((strlen(password) % 2) == 1):
		password.ljust(strlen(password) + 1)
	first = password[0:strlen(password)/2]
	second = password[strlen(password)/2:strlen(password)]
	crc1 = crc32(first)
	crc2 = crc32(second)
	if(crc1 < 0):
		crc1 = (crc1 * -1);

	if(crc2 < 0) :
		crc2 = (crc2 * -1);

	result = {"key": crc1, "key2": crc2}
	return result

def encrypt(keyarr, text):
	key = decimal.Decimal(keyarr['key'])
	key2 = decimal.Decimal(keyarr['key2'])
	mathlog1 = decimal.Decimal(text) / decimal.Decimal(key)
	log = log_base(key2, mathlog1) * key
	encrypted = base64.b64encode(repr(log))
	return encrypted

def decrypt(keyarr, text):
	key = keyarr['key']
	key2 = keyarr['key2']
	b64 = base64.b64decode(text)
	floatb64 = decimal.Decimal(b64[9:strlen(b64)-2])
	decrypted = math.pow(key2, (floatb64 / key)) * key
	return long(decrypted)

def stringToASCII( string ):
	d = {}
	i = 0
	for c in string:
		d[i] = ord(c)
		i = (i + 1)

	return d

def encryptStringASCIIArray( keyarr, array ):
	i = 0
	out = {}
	print len(array)
	for key, value in array.iteritems():
		out[i] = encrypt(keyarr, decimal.Decimal(value))
		i = (i + 1)
	return out

def decryptStringASCIIArray( keyarr, array ):
	i = 0
	out = {}
	print len(array)
	for key, value in array.iteritems():
		out[i] = chr(decrypt(keyarr, value))
		i = (i + 1)
	return out
inputtext = 'TEST'
try:
	command = sys.argv[1]
except IndexError:
    commandline = 15
    inputtext = 'TEST'
    command = 'TEST'
try:
    commandline = decimal.Decimal(command)
except decimal.InvalidOperation:
    inputtext = command
    commandline = 15

encrypted = encrypt(generateKey( 'supergeheimespasswort' ), commandline)
print encrypted
decrypted = decrypt(generateKey( 'supergeheimespasswort' ), encrypted)
print decrypted
encryptString = stringToASCII(inputtext)
print encryptString
encryptedArr = encryptStringASCIIArray(generateKey( 'supergeheimespasswort' ), encryptString)
print encryptedArr
print decryptStringASCIIArray(generateKey( 'supergeheimespasswort' ), encryptedArr)

Ich benutze übrigens immer zwei Keys.
$\begin{eqnarray*} log_{key2}(input / key)* key = output \end{eqnarray*}$
$\begin{eqnarray*} key2^{output / key}* key = input \end{eqnarray*}$

Zurzeit ist es schon möglich, ganze Zeichenketten zu Verschlüsseln.
Das einzige Problem: bei einigen ASCII-Zeichen (alle, die ich beisher gefunden habe über 100.

Die ZEichenkette ist in diesem dict abgebildet:

code:

1:
2:
3:
4:
5:
6:
7:

{0: 97, 1: 98, 2: 99, 3: 100, 4: 101, 5: 102, 6: 103, 7: 104, 8: 105, 9: 106, 10
: 107, 11: 108, 12: 109, 13: 110, 14: 111, 15: 112, 16: 113, 17: 114, 18: 115, 1
9: 116, 20: 117, 21: 118, 22: 119, 23: 120, 24: 121, 25: 122, 26: 65, 27: 66, 28
: 67, 29: 68, 30: 69, 31: 70, 32: 71, 33: 72, 34: 73, 35: 74, 36: 75, 37: 76, 38
: 77, 39: 78, 40: 79, 41: 80, 42: 81, 43: 82, 44: 83, 45: 84, 46: 85, 47: 86, 48
: 87, 49: 88, 50: 89, 51: 90, 52: 48, 53: 49, 54: 50, 55: 51, 56: 52, 57: 53, 58
: 54, 59: 55, 60: 56, 61: 57}

entspricht:

code:
1:	abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789

diese entspricht dieser Verschlüsselung:

code:

1:
2:
3:
4:
5:
6:
7:

{0:'RGVjaW1hbCgnLTg3MDg2MTUxLjIwNDMyNDYwOTE0NDY3NjI4MjA5MTM0MjE0NDMyNDgzNzkwNTc1OTE2OTQ1NjYwMTg3NjAzODYxNjA2OTQ4MTUwMjc1MjQxOTc4MzI5NDY3NDIzMTU3ODM0NDExMzYxODg4MjAxNzY3MjU4NjIxNzI3NTM4MDE2MjYxNjEzNTEyODcyNzkyMzkxNzU3MjY0ODUzMTExMTMxNDYyNjA4MzYyMTcyMTM3MTYzMjg1MjgwODY2MTE2ODAyODkwMDU3NzMzNzExNDAyNzE4NTc1OTU2OTI3NTM4MzQ2MDE5OTEyMTg0MjU0OTEzNjY4MjUzNTk2NTUzNzM2MTA5NjkyMzY5NDA5OTk1OTgzNTYxNjg2NzgwMTg0ODc5ODgxNjAxNTY0MTE0NDIwMDg2NTcxMzMzNzM3MjQ1ODI0ODI4MzE0NTE1ODU1NDExMzcyNzgxMzM5MjY1MDUwMzY0NjY3NTM5NjU2ODg4ODE4MTQxOTI5ODQ2NjE1NTYyNTMzODkwNDAzODQ1Mjk0Mjk4ODYzOTQ1NDA4MjU3NTA1MzA3OTEzMjMyNjUyODI5NTg5NTQyMTU4NTcxNTk3NTgzNjMyMjg1NDkwODExNDM0ODk4ODk2OTAyNjY4MzE3MzMwODQ0NTM4MTI2MTAyMjI4MzY5NjAxMTUxMzgyMzQ0MTI5MDkwODkxMjA3MDA4OTEwMD
A4NjM2Mzc0NDk1MzIwNzA3NzU3MDE0NDc0MTUyMzQ5Mzc4MzM1NTI4NTIyMTc3MTQwODQ2NDIwMzc2NDIzNzg0NzE5MDI2NDQ5NjYzNzg3Njg3NjQwMjQ5MDI2OTMwNDk5NDc5NjgxNTM4NDg3MDg2MDk2Nzk3MzMyNzgyOTgzMTY2Njc5MjU3NTA0NDkyNDM1NTUzOTE4MTg3MzM1NjI4ODI2OTAwMzE3OTcxNzA4NTQ3MjU1MDczMDkwODQxODAxMTc1ODE4ODE2NDkwNjA1MDE1MjA5MjEzNTg5ODA0ODcyOTI1NDAzMjEzODMzNDY4ODY1NzgxODg5NDU4NjA4NjA5Mjc3NDIwMTU2MzA4MDkzMzEwNTgwNzkxODg0MDY4MTg2NTgwNzg2ODc5OTQxMjAzNzgzMjIzNzI4NTY4MDc2NjgxODYxNjI5ODcwMDI4Njk5NTExMzIyMTk3NzA4Njc0MzQ4MjcwNDQ0Mjg1MDExODk0NzE0NTQzODE2MzgwNzM0ODAxOTIwMjcwNTAyMDIzMjMzNTQwMDgyODI4MDAzNDU0NTg0OTYzNzkxMDk1ODkyMTQ1NTY3MDI0MDE1ODY0NjM2NzAxNjA1NDc0MjY4ODU4NTcwMDYyMjY4MzYzNzI0MzUzNDE2NjcxMTc2MDgzMjU5ODgxMjI5NTU0OTMyMTk2OTkzNTUxODMyNjgzNzU4OTY2MDQyOTgyMDM2MjI1NDQxNDE3NzY5ODA5NTI0ODg3MTc2OTE3NTAwMTI5NDY4MjU2MjU1MDAwODY4MDM4NzYwMzY2NTA4NDc2MDgyNjgwMjc0MTQ4MjMxNTA4Nzk5NDU4Nzc2
OTQ2NzIyNDY1MjUxMDk3ODQxOTkyOTMyMDQyMTc4OTg0NDkyNjIwMDk1MjI1MDAzMDEyMzMwODY3MDEwNzk4MjM3MjQ4MjI5NDE2MTY5NDY2ODk1MjQxMzE5ODQzNjMxOTYwNzY5NTExMzI2NzA2MDQwMTE4OTQxMjcwNDMyMzYyNjkyNTUwNzgxODY2MTE3OTExMjMwMjA1Njg5ODQ0NjU3NzkxMjgyMzI1MDI4MzE1NjAyNTk2MTE5OTUxNDY0NjYwMDAzNTE5MTYzMDUzMTYyNDY5ODI2MjE5NTc1MTgyODYwMDIxMDEwOTY2NTIzOTI2OTM1MTcyMDcwMDI1ODU3Mzg3OTYwNjgyMzUyMjA0MjE0OTQ4ODY0NjExMzk0MDg4MDc2NjM3NzgxNTYxMzAzMTI3MDM3OTMxNzQ3MzYyOTc5NjQ3MDgyMDA5MTE3NTU1NzUxMDIzMDI0MzA3NzE2MDc2MjY5NzUxMTc0Mjg3MDEzMTA5MjE2MzMwMDY1MTM3MDc1MzcxNjYyMDEzMTcxMDk0NTcxNTE4MTQ2MTI2MzQ1MjkyMjA0MDY0NzczMDM0M
TU0NTc3ODU4MzkyMDQ3NzcyODAyNjEwNTIwMjU0NDU4MTkyNTQxOTEwNTUwNTg4NTQwNDQ0MjIxMjkxNDc1NDE2NjQyNTc3NTU4MzY1NDcxNjYyNDY1MzY5NDY2MDg2MDAzNzEwMTMzMjEzMzE4MTM2NjA0ODU3Mjg2NzExNDE3ODkwNDE2NTg3MTMzMzEwNDY5ODcxOTY3ODI2NTc5OTQzNzgzOTk4ODg4OTkzMzU1NDA2ODIzNTc4MTMzODM2MDIyNzgwOTIzNzA4MDIyMTEwNTUxNjA2Njg3OTg2NTM4MjIyMDM1MTk0NjA0Nzc2MzIzMTc4ODU2MTMwMjA2OTkwNTcxNzc1Mjk5NTQzNjM1ODQ0NjQ2MzQ2MTEzNjQ4NjM0MDcyODE5MTI0MDkzMTUwMTc0MzQzNzc3NDM3NjQ0ODU4Njk1NTI0MzQ5NDk5MTk0OTc2Mjk5MDExMDY0MDMzNzEzMTA2MDEyODAyMTgzNjU1NTgwMjk3MTczNzA3
MzM2MjYyNzQyNTk0NzQ2MTE0MTY3NTAxMDEzNTA5MTEyNjcyNzM3ODc0Nzk3NDIxNzI5MTcxMjk1OTQxMDMwNjU2OTk4ODkzODYxMTA4MD.... usw.

Nach der Entschlüsselung wird daraus:

code:

1:

 {0: 'a', 1: 'a', 2: 'b', 3: 'c', 4: 'e', 5: 'e', 6: 'g', 7: 'h', 8: 'h', 9: 'j', 10: 'j', 11: 'l', 12: 'l', 13: 'n', 14: 'o', 15: 'p', 16: 'q', 17: 'q', 18: 's', 19: 't', 20: 'u', 21: 'v', 22: 'w', 23: 'x', 24: 'y', 25: 'z', 26: 'A', 27: 'B', 28: 'B', 29: 'D', 30: 'D', 31: 'F', 32: 'F', 33: 'G', 34: 'I', 35: 'I', 36: 'K', 37: 'L', 38: 'L', 39: 'M', 40: 'O', 41: 'P', 42: 'P', 43: 'R', 44: 'S', 45: 'T', 46: 'T', 47: 'V', 48: 'W', 49: 'W', 50: 'Y', 51: 'Z', 52: '/', 53: '1', 54: '2', 55: '3', 56: '3', 57: '4', 58: '5', 59: '6', 60: '8', 61: '9'}

Also leider nichtmehr unsere Eingangszeichenkette.

23.11.2014, 12:13

URL

Auf diesen Beitrag antworten »

RE: Logarithmus nicht als Kommazahl

code:
1: 2:	mathlog1 = decimal.Decimal(text) / decimal.Decimal(key) log = log_base(key2, mathlog1) * key

Dein Verschlüsselungstext ist
$\begin{eqnarray*} c=\log_{key2}(\frac {text}{ key})key \end{eqnarray*}$
richtig?
Wenn du zwei Nachrichten mit dem gleichen Schlüssel verschlüsselst, ist
$\begin{eqnarray*} \frac{c_1}{c_2}=\frac{\log_{key2}(\frac {text_1}{ key})key}{\log_{key2}(\frac {text_2}{ key})key} =\frac{\log_{key2}(\frac {text_1}{ key})}{\log_{key2}(\frac {text_2}{ key})}=\frac{\log(\frac {text_1}{ key})\log_{key2}(10)}{\log(\frac {text_2}{ key})\log_{key2}(10)} =\frac{\log(\frac {text_1}{ key})}{\log(\frac {text_2}{ key})} \end{eqnarray*}$
also
$\begin{eqnarray*} \left(\frac {text_2}{key} \right)^{c_1/c_2}=\frac {text_1}{key} \end{eqnarray*}$
Dein key2 spielt also gar keine Rolle.

Edit: Mein Post hat nicht unmittelbar mit deinem Entschlüsselungsproblem zu tun. Ich stelle mir nur die Frage, ob deine Verschlüsselung überhaupt sinnvoll ist verwirrt

23.11.2014, 13:04

jankal

Auf diesen Beitrag antworten »

RE: Logarithmus nicht als Kommazahl

Zitat:

Original von URL

code:
1: 2:	mathlog1 = decimal.Decimal(text) / decimal.Decimal(key) log = log_base(key2, mathlog1) * key

Also sollte ich lieber bloß mit einem Schlüssel und der Basis 10 verschlüsseln?

sähe dann so aus:
$\begin{eqnarray*} log_{10}(\frac{input}{key})* key = output \end{eqnarray*}$
$\begin{eqnarray*} 10^{\frac{output}{key}}* key = input \end{eqnarray*}$

Dann hätte man, so wie ich das verstanden habe keinen Overhead durch $\begin{eqnarray*} key2 \end{eqnarray*}$ mehr.

Aber wäre es dann sicher?

Ich habe das nun mal korrekt(Basis = 10, key = crc32(input)) in mein Python-Programm implementiert.

Trotzdem habe ich immernoch folgendes Problem:

code:

1:
2:
3:
4:
5:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789

wird zu

{0: '`', 1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'f', 6: 'f', 7: 'h', 8: 'i', 9: 'i', 10: 'k', 11: 'k', 12: 'l', 13: 'm', 14: 'n', 15: 'o', 16: 'q', 17: 'q', 18: 'r', 19: 't', 20: 't', 21: 'u', 22: 'v', 23: 'w', 24: 'x', 25: 'z', 26: 'A', 27: 'A', 28: 'B', 29: 'C', 30: 'E', 31: 'E', 32: 'F', 33: 'H', 34: 'H', 35: 'I', 36: 'K', 37: 'K', 38: 'L', 39: 'M', 40: 'N', 41: 'O', 42: 'P', 43: 'Q', 44: 'R', 45: 'S', 46: 'T', 47: 'U', 48: 'V', 49: 'X', 50: 'X', 51: 'Y', 52: '0', 53: '0', 54: '1', 55: '3', 56: '4', 57: '4', 58: '5', 59: '6', 60: '7', 61: '8'}

23.11.2014, 13:09

URL

Auf diesen Beitrag antworten »

RE: Logarithmus nicht als Kommazahl
Weglassen von key2 macht es jedenfalls nicht unsicherer. Auch die Multiplikation des Logarithmus mit key an der Stelle
$\begin{eqnarray*} c=\log_{key2}(\frac {text}{ key})key \end{eqnarray*}$ ist überflüssig. Er kürzt sich doch ohnehin heraus, wenn man zwei Verschlüsselungstexte hat.

23.11.2014, 13:17

jankal

Auf diesen Beitrag antworten »

RE: Logarithmus nicht als Kommazahl

Zitat:

Original von URL
Weglassen von key2 macht es jedenfalls nicht unsicherer. Auch die Multiplikation des Logarithmus mit key an der Stelle
$\begin{eqnarray*} c=\log_{key2}(\frac {text}{ key})key \end{eqnarray*}$ ist überflüssig. Er kürzt sich doch ohnehin heraus, wenn man zwei Verschlüsselungstexte hat.

Laut meinen Tests würde das nicht funktionieren.

$\begin{eqnarray*} log_{10}(\frac{input}{key})= output \end{eqnarray*}$
$\begin{eqnarray*} 10^{output}* key \neq input \end{eqnarray*}$

Setzten wir doch einfach mal 12 für den $\begin{eqnarray*} key \end{eqnarray*}$ und 15 für den $\begin{eqnarray*} input \end{eqnarray*}$ ein.

$\begin{eqnarray*} log_{10}(\frac{15}{12})= output \end{eqnarray*}$
$\begin{eqnarray*} 10^{output}* 12 \neq 15 \end{eqnarray*}$

weil $\begin{eqnarray*} output = 0,96910013008056 \end{eqnarray*}$

Zumindest sagt das mein Taschenrechner im Deg Modus.

Dabei wäre
$\begin{eqnarray*} 10^{0,96910013008056}* 12 = 111,75870895385634 \end{eqnarray*}$

23.11.2014, 13:18

URL

Auf diesen Beitrag antworten »

RE: Logarithmus nicht als Kommazahl
Du musst dann natürlich auch beim Entschlüsseln die Multiplikation weglassen Augenzwinkern

23.11.2014, 13:21

jankal

Auf diesen Beitrag antworten »

RE: Logarithmus nicht als Kommazahl

Zitat:

Original von URL
Du musst dann natürlich auch beim Entschlüsseln die Multiplikation weglassen Augenzwinkern

Du meinst also so:
$\begin{eqnarray*} log_{10}(\frac{input}{key})= output \end{eqnarray*}$
$\begin{eqnarray*} 10^{\frac{output}{key}}* key = input \end{eqnarray*}$

Meiner Rechnung nach würde das sogar zutreffen.
$\begin{eqnarray*} log_{10}(\frac{15}{12})= 0,96910013008056 \end{eqnarray*}$
$\begin{eqnarray*} 10^{\frac{0,96910013008056}{12}}* 12 = 15 \end{eqnarray*}$

23.11.2014, 13:36

URL

Auf diesen Beitrag antworten »

RE: Logarithmus nicht als Kommazahl
Also da passt etwas für mich nicht zusammen. Wenn
$\begin{eqnarray*} log_{10}(\frac{input}{key})= output \end{eqnarray*}$
dann ist
$\begin{eqnarray*} 10^{output}* key = input \end{eqnarray*}$

Wenn
$\begin{eqnarray*} log_{10}(\frac{input}{key})key= output \end{eqnarray*}$
dann ist
$\begin{eqnarray*} 10^{\frac{output}{key}}* key = input \end{eqnarray*}$

23.11.2014, 13:55

jankal

Auf diesen Beitrag antworten »

RE: Logarithmus nicht als Kommazahl

Zitat:

Original von URL
Also da passt etwas für mich nicht zusammen. Wenn
$\begin{eqnarray*} log_{10}(\frac{input}{key})= output \end{eqnarray*}$
dann ist
$\begin{eqnarray*} 10^{output}* key = input \end{eqnarray*}$

Wenn
$\begin{eqnarray*} log_{10}(\frac{input}{key})key= output \end{eqnarray*}$
dann ist
$\begin{eqnarray*} 10^{\frac{output}{key}}* key = input \end{eqnarray*}$

Stimmt irgendwie. Ich habe es genauer berechnet. und dabei kam $\begin{eqnarray*} 12.225231181458074 \end{eqnarray*}$ raus.

$\begin{eqnarray*} log_{10}(\frac{15}{12}) = 0.0969100130080564 \end{eqnarray*}$
$\begin{eqnarray*} 10^{\frac{0.0969100130080564}{12}}* 12 = 12.225231181458074 \end{eqnarray*}$

richtig wäre:

$\begin{eqnarray*} log_{10}(\frac{15}{12}) = 0.0969100130080564 \end{eqnarray*}$
$\begin{eqnarray*} 10^{0.096910013008056412}* 12 = 15 \end{eqnarray*}$

Was sich auch eindeutig beweisen lässt (Ruby code):

code:
1: 2: 3: 4: 5: 6: 7: 8: 9:	>> log = Math.log((15.to_f/12.to_f), 10) => 0.0969100130080564 >> (10.to_f*log.to_f)12.to_f => 15.0 ABER >> (10.to_f*(log.to_f / 12.to_f))12.to_f => 12.225231181458074

Neue Frage »

Antworten »

Logarithmus nicht als Kommazahl

Verwandte Themen