Solver für Gleichungen

Die beste die ich bisher habe ist:
a= 0, b= 1, c= 2, d= 11, e= 11, f= 1, g= 1, h= 4

Abstand: 2.6e-005


Code:
int _tmain(int argc, _TCHAR* argv[])
{
	double dist = 553.4589;
	double produkt = 0.0;
	// 12*a+b*14,00307+c*15,99491+d*1,00783+e*22,98977+f*54,93805+g*34,96885+h*38,39637 1=553,4589
	for (int a = 0; a < 51; ++a)
		for (int b = 0; b < 51; ++b)
			for (int c = 0; c < 51; ++c)
				for (int d = 0; d < 51; ++d)
					for (int e = 0; e < 51; ++e)
						for (int f = 0; f < 51; ++f)
							for (int g = 0; g < 51; ++g)
								for (int h = 0; h < 51; ++h)
								{
									produkt = 
										12.0*a+
										b*14.00307+
										c*15.99491+
										d*1.00783+
										e*22.98977+
										f*54.93805+
										g*34.96885+
										h*38.396371;
									if ((fabs(produkt - 553.4589)) < dist) // Verbesserung
									{
										std::cout << "a= " << a
											<< ", b= " << b
											<< ", c= " << c
											<< ", d= " << d
											<< ", e= " << e
											<< ", f= " << f
											<< ", g= " << g
											<< ", h= " << h << "\n";
										dist = fabs(produkt - 553.4589);
										std::cout << "dist= " << dist << "\n";
									}
								}
	return 0;
}






AUSGABE
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 0, h= 1
dist= 515.063
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 0, h= 2
dist= 476.666
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 0, h= 3
dist= 438.27
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 0, h= 4
dist= 399.873
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 0, h= 5
dist= 361.477
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 0, h= 6
dist= 323.081
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 0, h= 7
dist= 284.684
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 0, h= 8
dist= 246.288
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 0, h= 9
dist= 207.892
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 0, h= 10
dist= 169.495
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 0, h= 11
dist= 131.099
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 0, h= 12
dist= 92.7024
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 0, h= 13
dist= 54.3061
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 0, h= 14
dist= 15.9097
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 2, h= 13
dist= 15.6316
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 3, h= 12
dist= 12.2041
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 4, h= 11
dist= 8.77658
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 5, h= 10
dist= 5.34906
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 6, h= 9
dist= 1.92154
a= 0, b= 0, c= 0, d= 0, e= 0, f= 0, g= 7, h= 8
dist= 1.50598
a= 0, b= 0, c= 0, d= 0, e= 0, f= 1, g= 0, h= 13
dist= 0.631973
a= 0, b= 0, c= 0, d= 0, e= 0, f= 2, g= 5, h= 7
dist= 0.036047
a= 0, b= 0, c= 0, d= 0, e= 3, f= 5, g= 6, h= 0
dist= 0.01376
a= 0, b= 0, c= 0, d= 1, e= 7, f= 0, g= 9, h= 2
dist= 0.010288
a= 0, b= 0, c= 0, d= 1, e= 12, f= 3, g= 1, h= 2
dist= 0.001912
a= 0, b= 0, c= 0, d= 10, e= 4, f= 3, g= 6, h= 2
dist= 0.001528
a= 0, b= 0, c= 0, d= 13, e= 3, f= 4, g= 5, h= 2
dist= 0.001392
a= 0, b= 0, c= 0, d= 50, e= 7, f= 0, g= 1, h= 8
dist= 0.000808
a= 0, b= 0, c= 1, d= 23, e= 2, f= 0, g= 9, h= 4
dist= 0.000774
a= 0, b= 0, c= 1, d= 36, e= 7, f= 2, g= 0, h= 6
dist= 0.000606
a= 0, b= 0, c= 1, d= 44, e= 15, f= 2, g= 0, h= 1
dist= 0.000449
a= 0, b= 0, c= 3, d= 32, e= 6, f= 0, g= 3, h= 6
dist= 0.000214
a= 0, b= 1, c= 1, d= 13, e= 3, f= 6, g= 1, h= 2
dist= 7.2e-005
a= 0, b= 1, c= 2, d= 11, e= 11, f= 1, g= 1, h= 4
dist= 2.6e-005
 
Zuletzt bearbeitet:
habs nochma geupdated

was heißt denn "taugt nicht"
sie stimmt erst in der 5ten Nachkommastelle nicht

edit: rechnet ja noch... abwarten :p

sonst überleg dir nochmal was genau du eigtl willst:
- alle lösungen die weniger als 0.001 dranliegen?
- zusätzliche nebenbedingungen erfüllen?
- die belegung, die der zahl am nahesten kommt?
 
Zuletzt bearbeitet:
mh scheint so als müsste ich mich doch mal mit c++ beschäftigen...
edit/ ich überleg mir noch paar sinnvolle einschränkungen... dauert kurz:)

so
9<=a=<40
1<=b=<15
0<=c=<20
0<=d=<10
0<=e=<9
0<=f=<5
0<=g=<10
0<=h=<9

wie kann ich das skript von dir ausführen?
 
Zuletzt bearbeitet:
Mathematica 8 liefert mir auf Anhieb keine Lösungen aus {n,...,50}. Ich sehe auch keinen anderen Lösungsansatz wie stupides Durchprobieren.
 
also erstmal danke an alle, aber ich mach für heute schluss. werd morgen mal in der uni schauen ob ich nen rechner mit matlab oder ähnlichem auftreiben kann
gn8;)
 
Mitlerweile sind noch
a= 0, b= 8, c= 2, d= 3, e= 0, f= 6, g= 0, h= 2
dist= 1.2e-005
a= 0, b= 10, c= 1, d= 43, e= 2, f= 3, g= 3, h= 1
dist= 1.1e-005
hinzugekommen.

Ich starts nochmal mit deinen Vorgaben neu.. das hier dauert ja ewig
Ergänzung ()

Update mit den neuen Randbedingungen

Code:
int _tmain(int argc, _TCHAR* argv[])
{
	double dist = 553.4589;
	double produkt = 0.0;
	// 12*a+b*14,00307+c*15,99491+d*1,00783+e*22,98977+f*54,93805+g*34,96885+h*38,39637 1=553,4589
	for (int a = 9; a < 41; ++a)
		for (int b = 1; b < 16; ++b)
			for (int c = 0; c < 21; ++c)
				for (int d = 0; d < 11; ++d)
					for (int e = 0; e < 10; ++e)
						for (int f = 0; f < 6; ++f)
							for (int g = 0; g < 11; ++g)
								for (int h = 0; h < 10; ++h)
								{
									produkt = 
										12.0*a+
										b*14.00307+
										c*15.99491+
										d*1.00783+
										e*22.98977+
										f*54.93805+
										g*34.96885+
										h*38.396371;
									if ((fabs(produkt - 553.4589)) < dist) // Verbesserung
									{
										std::cout << "a= " << a
											<< ", b= " << b
											<< ", c= " << c
											<< ", d= " << d
											<< ", e= " << e
											<< ", f= " << f
											<< ", g= " << g
											<< ", h= " << h << "\n";
										dist = fabs(produkt - 553.4589);
										std::cout << "dist= " << dist << "\n";
									}
								}
	return 0;
}

Ausgabe:
Code:
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 0, h= 0
dist= 431.456
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 0, h= 1
dist= 393.059
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 0, h= 2
dist= 354.663
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 0, h= 3
dist= 316.267
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 0, h= 4
dist= 277.87
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 0, h= 5
dist= 239.474
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 0, h= 6
dist= 201.078
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 0, h= 7
dist= 162.681
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 0, h= 8
dist= 124.285
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 0, h= 9
dist= 85.8885
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 1, h= 9
dist= 50.9196
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 2, h= 9
dist= 15.9508
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 4, h= 8
dist= 15.5905
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 5, h= 7
dist= 12.163
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 6, h= 6
dist= 8.7355
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 7, h= 5
dist= 5.30798
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 8, h= 4
dist= 1.88045
a= 9, b= 1, c= 0, d= 0, e= 0, f= 0, g= 9, h= 3
dist= 1.54707
a= 9, b= 1, c= 0, d= 0, e= 0, f= 1, g= 2, h= 8
dist= 0.590888
a= 9, b= 1, c= 0, d= 0, e= 0, f= 2, g= 7, h= 2
dist= 0.005038
a= 9, b= 1, c= 1, d= 7, e= 5, f= 0, g= 4, h= 4
dist= 0.003624
a= 9, b= 1, c= 5, d= 0, e= 0, f= 5, g= 0, h= 2
dist= 0.001712
a= 9, b= 1, c= 11, d= 1, e= 2, f= 1, g= 0, h= 4
dist= 0.000916
a= 9, b= 2, c= 2, d= 4, e= 6, f= 1, g= 1, h= 4
dist= 0.000616
a= 9, b= 4, c= 3, d= 8, e= 0, f= 2, g= 2, h= 4
dist= 3.4e-005

Dh
a= 9, b= 4, c= 3, d= 8, e= 0, f= 2, g= 2, h= 4
ist die dichteste Lösung, die alle deine Bedingungen erfüllt

wie kann ich das skript von dir ausführen?
Naja das ist 0-8-15 C++ code..
Am schnellsten gehts wenn du ne IDE wie Visual Studio Express oder Code::Blocks oder Eclipse für C++ holst wo nen Compiler schon bei ist und das einfach copy&paste in ein leeres Konsolen-Projekt reinkopierst.
#include <iostream>
#include <math.h>
muss noch dazu
 
Zuletzt bearbeitet:
hier mal mein ergebnis aus processing:
mit deinen randbedingungen und einem fehler<0,001 komm ich auf diese ergebnisse:
Code:
laufende nummer - 	a b c d e f g h		: ergebnis		// fehler
	0 - 		9 1 11 1 2 1 0 4	: 553.458		// 9.1552734E-4
	1 - 		9 2 2 4 6 1 1 4		: 553.45825		// 6.713867E-4
	2 - 		9 3 0 9 2 1 4 4		: 553.4581		// 7.9345703E-4
	3 - 		9 4 3 8 0 2 2 4		: 553.45886		// 6.1035156E-5
	4 - 		9 5 1 1 5 1 1 4		: 553.4593		// 3.6621094E-4
	5 - 		10 1 0 10 2 0 6 4	: 553.4595		// 5.493164E-4
	6 - 		10 2 1 10 2 2 2 4	: 553.4581		// 7.9345703E-4
	7 - 		10 2 8 0 3 1 0 4	: 553.45825		// 6.713867E-4
	8 - 		10 3 4 9 0 3 0 4	: 553.459		// 6.1035156E-5
	9 - 		10 5 0 7 1 2 2 4	: 553.4592		// 3.0517578E-4
	10 - 		10 5 2 3 0 0 5 4	: 553.4584		// 5.493164E-4
	11 - 		11 4 1 8 1 3 0 4	: 553.4592		// 3.0517578E-4
	12 - 		11 4 3 4 0 1 3 4	: 553.4584		// 5.493164E-4
	13 - 		12 1 5 0 4 0 2 4	: 553.45984		// 9.1552734E-4
	14 - 		12 2 3 5 0 0 5 4	: 553.4597		// 7.9345703E-4
	15 - 		12 3 4 5 0 2 1 4	: 553.45844		// 4.8828125E-4
	16 - 		12 5 0 3 1 1 3 4	: 553.45874		// 1.8310547E-4
	17 - 		13 1 4 6 0 1 3 4	: 553.4598		// 8.544922E-4
	18 - 		13 2 0 0 7 1 0 4	: 553.458		// 9.1552734E-4
	19 - 		13 4 1 4 1 2 1 4	: 553.45874		// 1.8310547E-4
	20 - 		13 7 0 1 0 2 1 4	: 553.4597		// 7.9345703E-4
	21 - 		13 13 9 10 1 0 0 1	: 553.45856		// 3.6621094E-4
	22 - 		14 14 6 9 2 0 0 1	: 553.4588		// 1.2207031E-4
	23 - 		15 1 4 2 0 0 4 4	: 553.4592		// 3.0517578E-4
	24 - 		15 4 1 0 1 1 2 4	: 553.4581		// 7.9345703E-4
	25 - 		15 15 3 8 3 0 0 1	: 553.4591		// 1.8310547E-4
	26 - 		16 2 1 1 1 0 4 4	: 553.4595		// 5.493164E-4
	27 - 		16 3 2 1 1 2 0 4	: 553.45825		// 6.713867E-4
	28 - 		16 13 1 10 5 0 0 1	: 553.4584		// 5.493164E-4
	29 - 		17 1 2 2 1 1 2 4	: 553.4596		// 6.713867E-4
	30 - 		19 1 0 2 2 2 0 4	: 553.45984		// 9.1552734E-4
	31 - 		19 5 1 9 0 0 0 6	: 553.4589		// 0.0
	32 - 		20 15 0 10 0 1 0 1	: 553.45874		// 1.8310547E-4
	33 - 		22 15 0 6 0 0 1 1	: 553.45825		// 6.713867E-4
	34 - 		24 12 1 8 0 0 1 1	: 553.4596		// 6.713867E-4
	35 - 		27 8 3 8 1 0 0 1	: 553.45807		// 8.544922E-4
	36 - 		27 11 2 5 0 0 0 1	: 553.45905		// 1.2207031E-4
	37 - 		28 9 0 7 2 0 0 1	: 553.4583		// 6.1035156E-4
	38 - 		29 5 4 10 1 0 0 1	: 553.4594		// 4.8828125E-4
	39 - 		30 6 1 9 2 0 0 1	: 553.4597		// 7.9345703E-4

und ich lass es gerade mit a-h von 0-50 durchlaufen, aber das dauert mehrere stunden wenn nicht tage mit processing also werd ich das wohl net fertig werden lassen können :)

edit:
also nach 20 minuten rechnen lassen, hatte er ca !!0.2%!! der möglichkeiten durchgerechnet und hatte schon 100 ergebnisse mit einem fehler<0.001 gefunden.

ich denke wenn man das die Woche (die es braucht) durchrechnen lässt, dann hast am schluss ne textdatei mit 50000 ergebnissen, und das nützt keinem was.
da sind die ergebnisse mit deinen einschränkungen schon besser (und das dauert nur sekunden zum berechnen)
 
Zuletzt bearbeitet:
Erst dachte ich ja dein (Brtwrst) Programm müsste fehlerfreier gerechnet haben als mein C++ mit "nur" 32bit-double genauigkeit.. aber deine "beste" Lösung:
19 5 1 9 0 0 0 6
ergibt mit von Hand nachrechnen
12*19+5*14,00307+1*15,99491+6*38,396371
228
+70,01535
+15,99491
+230,378226

544,388486
und nicht
553,4589

Darf ich fragen, womit du das ausgerechnet hast? Ist ja schon ne auffallend große Abweichung.. ich hab bei meinem aber auch Zweifel, obs "fehlerfreier" gerechnet hat.

Mal ausprobieren...
 
jo jetzt wo du's sagst.
muss wohl daran liegen, dass ich mit float gerechnet hab (weil processing double net wirklich unterstützt)

mal schauen ob ichs vielleicht noch ins basic reinschreib.

edit:
also mein Excel VBA sagt mir
Code:
n	-a b c d e f g h	  Ergebns	  //  Fehler
0	-9 1 11 1 2 1 0 4  :	  553,457984  //  9,15999999961059E-04 
1	-9 2 2 4 6 1 1 4  :	  553,458284  //  6,15999999922678E-04 
2	-9 3 0 9 2 1 4 4  :	  553,458154  //  7,46000000049207E-04 
3	-9 4 3 8 0 2 2 4  :	  553,458934  //  3,40000000278451E-05 
4	-9 5 1 1 5 1 1 4  :	  553,459324  //  4,23999999952684E-04 
5	-10 1 0 10 2 0 6 4  :	  553,459494  //  5,9400000009191E-04 
6	-10 2 1 10 2 2 2 4  :	  553,458174  //  7,25999999872329E-04 
7	-10 2 8 0 3 1 0 4  :	  553,458264  //  6,3599999998587E-04 
8	-10 3 4 9 0 3 0 4  :	  553,458954  //  5,39999999773499E-05 
9	-10 5 0 7 1 2 2 4  :	  553,459214  //  3,14000000003034E-04 
10	-10 5 2 3 0 0 5 4  :	  553,458394  //  5,05999999973028E-04 
11	-11 4 1 8 1 3 0 4  :	  553,459234  //  3,33999999952539E-04 
12	-11 4 3 4 0 1 3 4  :	  553,458414  //  4,86000000023523E-04 
13	-12 1 5 0 4 0 2 4  :	  553,459884  //  9,84000000016749E-04 
14	-12 2 3 5 0 0 5 4  :	  553,459754  //  8,54000000003907E-04 
15	-12 3 4 5 0 2 1 4  :	  553,458434  //  4,65999999846645E-04 
16	-12 5 0 3 1 1 3 4  :	  553,458694  //  2,06000000048334E-04 
17	-13 1 4 6 0 1 3 4  :	  553,459774  //  8,73999999953412E-04 
18	-13 2 0 0 7 1 0 4  :	  553,458064  //  8,36000000049353E-04 
19	-13 4 1 4 1 2 1 4  :	  553,458714  //  1,85999999871456E-04 
20	-13 7 0 1 0 2 1 4  :	  553,459754  //  8,54000000003907E-04 
21	-13 13 9 10 1 0 0 1  :	  553,458541  //  3,5899999988942E-04 
22	-14 3 4 1 0 1 2 4  :	  553,457914  //  9,85999999898013E-04 
23	-14 14 6 9 2 0 0 1  :	  553,458821  //  7,8999999914231E-05 
24	-15 1 4 2 0 0 4 4  :	  553,459254  //  3,54000000129417E-04 
25	-15 2 5 2 0 2 0 4  :	  553,457934  //  9,65999999948508E-04 
26	-15 4 1 0 1 1 2 4  :	  553,458194  //  7,05999999922824E-04 
27	-15 15 3 8 3 0 0 1  :	  553,459101  //  2,01000000060958E-04 
28	-16 2 1 1 1 0 4 4  :	  553,459534  //  6,34000000104606E-04 
29	-16 3 2 1 1 2 0 4  :	  553,458214  //  6,85999999973319E-04 
30	-16 13 1 10 5 0 0 1  :	  553,458341  //  5,58999999952903E-04 
31	-17 1 2 2 1 1 2 4  :	  553,459554  //  6,54000000054111E-04 
32	-19 1 0 2 2 2 0 4  :	  553,459854  //  9,53999999978805E-04 
33	-19 5 1 9 0 0 0 6  :	  553,458956  //  5,60000000859873E-05 
34	-20 15 0 10 0 1 0 1  :	  553,458771  //  1,2899999990168E-04 
35	-22 15 0 6 0 0 1 1  :	  553,458251  //  6,48999999953048E-04 
36	-24 12 1 8 0 0 1 1  :	  553,459611  //  7,11000000023887E-04 
37	-27 8 3 8 1 0 0 1  :	  553,458071  //  8,28999999953339E-04 
38	-27 11 2 5 0 0 0 1  :	  553,459111  //  2,1100000003571E-04 
39	-28 9 0 7 2 0 0 1  :	  553,458351  //  5,4899999997815E-04 
40	-29 5 4 10 1 0 0 1  :	  553,459431  //  5,31000000137283E-04 
41	-30 6 1 9 2 0 0 1  :	  553,459711  //  8,11000000112472E-04

was dein ergebnis bestätigt
 
Zuletzt bearbeitet:
Zurück
Oben