aiuto matematico

[Sargonsei]

....
Mi sono ripassato le equazioni di secondo grado a 2 incognite (inizio con 2 che è più semplice, poi passo a 3).
Ho usato il metodo della sostituzione, anche se per un eventuale programma C sarebbe meglio quello di Cramer.
Avevo pensato:
3x+5y=34
3x-5y-34=0
....

Se hai due incognite, ti servono 2 equazioni diverse.
3x+5y=34 e 3x-5y-34=0 sono la stessa equazione... quindi te ne manca sempre una.

Comunque, ponendo come condizioni che sia X che Y siano numeri INTERI e MAGGIORI di ZERO, andando per tentativi anche l'equazione 3x+5y=34 diventa risolvibile.
(34:3)=11 col resto di 1
(34:5)=6 col resto di 4
quindi, se cerchiamo solo numeri interi e maggiori di zero, vediamo che
x può essere solo un numero intero compreso fra 0 e 11
mentre
y può essere solo un numero intero compreso fra 0 e 6

Siccome fra i 6 possibili valori di y l'unico per cui la divisione dà un resto divisibile per il 3 è 5 allora y vale 5
e per trovare x applichiamo la sostituzione, quindi

3x+5y=34
da cui x=(34-5y):3 = (34-5*5):3 = (34-25):3 = 9:3 = 3

Quindi X=3 e Y=5.

[gila75]

Comunque, ponendo come condizioni che sia X che Y siano numeri INTERI e MAGGIORI di ZERO, andando per tentativi anche l'equazione 3x+5y=34 diventa risolvibile.

Son sempre interessanti i tuoi spunti Saragonesi, e ti ringrazio. Ma calcola che in realtà sono 3 incognite, ho iniziato con 2
per rispolverare...mi capirai dopo quasi 25 anni ricordo poco.
Non vorrei che con 3 incognite il procedimento diventi complesso in modo esponenziale.
Volevo usare il sistema di equazioni, ma come detto se sono equivalenti diventa indeterminata se non erro.
bhò ci penso ancora un po' e rileggo bene il tuo post.
Intanto grazie

[Sargonsei]

Dimenticavo...
se proviamo a sostituire ad Y tutti i numeri interi da 0 a 6, vediamo che sono validi anche i valori

Y=2; x=(34-5y):3=(34-10):3=24:3=8
Y=5: x=(34-5y):3=(34-25):3=9:3=3 (già visto)

[Dahman]

@Dahman: scusa la domanda idiota, ho guardato le diofantee, e per ora ho trovato esempi a 2 incognite.
Funzionano anche a 3 incognite giusto?

Si, prova questi link.

Libro equazioni diofantee

numeri

ciao
dahman

[gila75]

Molte grazie Dahman, davvero interessante al di la del problema proposto da me. Sempre bello leggere certe cose.
Ho solo dato uno scorcio, domani (mannaggia al tempo, spero di averne) proseguo.

[stefano_carniel]

Come è già stato scritto esistono più soluzioni a questo tipo di problemi.
Nel caso specifico dell'esempio che hai fatto sono possibili soluzioni sia: X=1 Y=4 Z=0 che X=1 Y=1 Z=2

Servono necessariamente altre informazioni per poter selezionare una soluzione univoca.
Ad esempio:
- minor numero di contenitori
- minor costo (serve conoscere il costo di ogni contenitore)

...che è esattamente un problema di programmazione lineare

[runblade]

Come è già stato scritto esistono più soluzioni a questo tipo di problemi.
Nel caso specifico dell'esempio che hai fatto sono possibili soluzioni sia: X=1 Y=4 Z=0 che X=1 Y=1 Z=2

Servono necessariamente altre informazioni per poter selezionare una soluzione univoca.
Ad esempio:
- minor numero di contenitori
- minor costo (serve conoscere il costo di ogni contenitore)

...che è esattamente un problema di programmazione lineare

Vedasi risoluzione a problemi di programmazione lineare mediante metodo del simplesso

[Dclaudio1990]

Comunque, ponendo come condizioni che sia X che Y siano numeri INTERI e MAGGIORI di ZERO, andando per tentativi anche l'equazione 3x+5y=34 diventa risolvibile.

Son sempre interessanti i tuoi spunti Saragonesi, e ti ringrazio. Ma calcola che in realtà sono 3 incognite, ho iniziato con 2
per rispolverare...mi capirai dopo quasi 25 anni ricordo poco.
Non vorrei che con 3 incognite il procedimento diventi complesso in modo esponenziale.
Volevo usare il sistema di equazioni, ma come detto se sono equivalenti diventa indeterminata se non erro.
bhò ci penso ancora un po' e rileggo bene il tuo post.
Intanto grazie

Non ha alcun senso utilizzare i sistemi su equazioni equivalenti, il sistema "risponde" alla seguente domanda "quale coppia (in questo caso) di valori (x,y) risolve entrambe le equazioni messe a sistema", è ovvio che per due equazioni equivalenti queste coppie sono tali e quali a tutte le soluzioni possibili.
Poi Wolframe alpha non restituisce una singola soluzione, ma restituisce il sistema da impostare, con condizioni di campo incluse, per risolvere l'equazione.

[gila75]

Poi Wolframe alpha non restituisce una singola soluzione, ma restituisce il sistema da impostare, con condizioni di campo incluse, per risolvere l'equazione.

è vero. Solo ora che sto "ripassando" ricomincio a interpretare le varie scritture matematiche, tra cui quella di Wolframe Alpha.
Mi sto concentrando sulle diofantee, ma tutto implica un ripasso generale, e dopo 25 anni non è semplice.
Comunque grazie a tutti.

[gila75]

Mi sono studiato un po' le equazioni diofantee...che faticaccia a digiuno come sono di matematica.
Mi sono scritto un programma che calcola le identità di Bezout e tutto il resto.
per le identità ho usato il sistema a matrice. Ho trovato spunto da qui:
https://www.youtube.com/watch?v=gfC0zVLOBAc
in spagnolo, ma fa nulla.
meno male perchè a raccogliere i fattori col metodo classico sarebbe stato un suicidio...presumo si dovesse trasformare in una stringa, poi fare
un parsing ecc..
per ora uso 2 incognite. I dati 75 e 33 sono fissi, mentre il liquido può variare.
per il momento si varia solo ricompilando. l'input interattivo verrà dopo.
Questa è una bozza, devo scrivere la routine che calcola tutti le x e y possibili, ma solo positive.
Nel mio caso infatti una soluzione negativa non serve, tanto più come detto da voi che sarebbero infinite.
Ecco la bozza, spero sia esente da bug. Il caso particolare con MCD 1 lo devo ancora gestire (vedere il programma)

Codice: Seleziona tutto

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>
#include<math.h>

int mcd(int min,int max, int tab[][4],int *n);
void min_max (int *a,int *b);
void stampa (int n,int tab[][4]);
int bez (int a,int n,int tab[][4],int liquido);
int bez_2 (int b,int n,int tab[][4],int liquido);
void init_array(int tab[][4],int a,int b);
void riduci(int *a,int *b, int *liquido,int res);
void test(int mcd, int l);
void risolvi (int p,int a, int b,int liquido);


//***********************************************
// scambia numeri per trovare il massimo dei 2
//***********************************************
void min_max (int *a,int *b)
{
	int temp;
	if (*a<*b)
	{
		temp=*a;
		*a=*b;
		*b=temp;
	}
}

//***********************************************
// trova MCD metodo di Eulero
//***********************************************
int mcd(int min, int max,int tab[][4],int *n)
{
	int r = 1;
	int res;
	
	if (min == 0)
    	return max;
    else
    	while (r > 0)
		{
        	r = max % min;
			res=max/min;
        	max = min;
        	min = r;
			tab[*n+1][0]=min;
			tab[*n][1]=res;
			*n=(*n)+1;
		}
	
	return max;
}

//***********************************************
// test: se il liquido non è un multiplo dei
// 2 membri (75,33 nel mio) caso
// il risultato sarà frazionario e a me non va bene
//*************************************************
void test(int mcd, int l)
{
	if ( (l/mcd)-(float)(l)/(float)(mcd)!=0 )
	{	
		puts(" impossibile risultato frazionario");
		exit(0);
	}
	if (mcd==1)
		puts("caso particolare...");
}

void riduci(int *a,int *b, int *liquido,int res)
{
	*a=*a/res;
	*b=*b/res;
	*liquido=*liquido/res;
}

//***********************************************
// preparo l'array per il calcolo
// dei coefficienti di Bezout
//***********************************************
void init_array(int tab[][4],int a,int b)
{
	tab[0][0]=a;
	tab[1][0]=b;
	tab[0][2]=1;
	tab[1][3]=1;
}
//***********************************************
// calcolo identità p di Bezout
//***********************************************
int bez (int a,int n,int tab[][4], int liquido)
{
	int i;
	for (i=0; i<n; i++)
	{
		tab[i+2][2]=tab[i][2]-(tab[i+1][1]*tab[i+1][2]);
	}	
	return tab[n-1][2]*liquido;
}


//***********************************************
// calcolo identità q di Bezout
//***********************************************
int bez_2(int b,int n,int tab[][4],int liquido)
{
	int i;
	for (i=0; i<n; i++)
	{
		tab[i+2][3]=tab[i][3]-(tab[i+1][1]*tab[i+1][3]);
	}
	return tab[n-1][3]*liquido;
}

//***********************************************
// eventuale stampa per vedere la matrice
// che mi permette di vedere i passaggi
// e le identità di B.
//***********************************************
/*void stampa (int n,int tab[][4])
{
	int r,c;
	for (r=0; r<n; r++)
	{
		for (c=0; c<4; c++)
		{
			printf ("%d ", tab[r][c]);
		}
		puts("");
	}
}*/

//***********************************************
// calcola prima x, poi y
//***********************************************
	
void risolvi (int p,int a,int b,int liquido)
{
	int res,x,y;
	res=p/b;	
	x=p-(res*b);
	y=(liquido-(a*x))/b;
	printf ("x=%d y=%d\n", x,y);
}

	


int main (void)
{
	int a=75; //x
	int b=33; //y
	int liquido=816;
	int res,p,q;
	int tab[50][4]={{0},{0}};
	int n=0;
	min_max(&a,&b);
	res=mcd(a,b,tab,&n);
	test(res,liquido);
	riduci (&a,&b,&liquido,res);
	init_array(tab,a,b);
	p=bez(a,n,tab,liquido);
	q=bez_2(b,n,tab,liquido);
	//stampa(n,tab);
	risolvi(p,a,b,liquido);
	printf ("p=%d q=%d\n",p,q);
	printf ("liquido %d A=%d b=%d\n",liquido,a,b);
	
	return 0;
	
}

Spero sia tutto corretto a livello matematico. I conti sembrerebbero tornare.
Per 3 incognite avete dei consigli?
Grazie a chi avrà voglia di rispondermi.

PS: scusate ma in alcuni punti mi perde l'identazione...bhò

[gila75]

Ho ampliato il programma in modo tale che se non c'è modo di imbottigliare senza scarto man mano scala di un cl.
Poi restituisce la prima quantità valida con lo scarto es:
78 cl
x(75) =1 y(33)=0 scarto 3 cl.
Purtroppo ho un bug su alcune quantità. Appena è a posto lo pubblico.
Intanto mi sto dando da fare per capire con 3 incognite.
Il programma definitivo (per come mi ero posto l'obbiettivo) è 75,50,33.
Spero che da 2 a 3 incognite non cambi tutta la solfa, altrimenti devo riscrivere daccapo.

[BlueEyes]

Ciao gila.
Voglio dare anch'io un contributo alla tua interessante discussione, sperando che possa agevolarti nel perfezionamento del tuo codice in C.

In linea di principio, una sola equazione in 3 incognite ha, come dicono i matematici, infinito^2 soluzioni, sia nell'ambito dei numeri reali, che in quello dei numeri interi, come mostra la 'soluzione intera' di Wolpham, che utilizza le due variabili n_1 ed n_2.

Va da sé, però, che per risolvere il tuo quesito bisogna restringere il campo dei numeri a quello dei numeri interi _non_ negativi e, soprattutto _non_ nulli, perché non ha senso un numero di barattoli uguale a zero.

In questo caso la soluzione diventa unica e vale: [x=1,y=1,z=2]
Cheers

[gila75]

Ciao BluEyes ! Era da un po' che non ci si incontrava
Si uso anche io Wolframe per fare controprove, e in effetti sembra funzionare il mio programma C.
Non trovo un bug sulla versione che man mano scala es:
65 cl/3 (mcd tra 75 e 33)=21.6 (frazionario, quindi impossibile)
64cl/3 =21.3
....
60/3 =20 mod 0 (possibile, ma sicuramente x o y sono negative--->scartare)
dovrei arrivare a 33 scarto 32. 33+32=65
Come detto mi sto arrovellando su un bug. Sistemo una cosa e ne va a pallino un'altra.
Comunque con pazienza credo che risolverò
Il cruccio ora è capire la risoluzione delle diofantee in 3 incognite.
per esempio a 2 incognite:
Calcolo l'mcd tra (mio caso) 75 e 33--->3
Calcolo le identità di Bezout : 4, -9
Come si fa con 3??
Ok, potrei calcolare sempre l'mcd: 75,50,33--->1
ma le indentità, come devo procedere?
Mi sa che devo isolare un'incognita e risolvere x,y (dico così senza nessuna base)
Quello mi sta bloccando...a dire il vero mi blocca il caldo, la mancanza di tempo, il lavoro...fosse per me starei qui ore

[BlueEyes]

Ciao gila.
Un procedimento "a cascata" potrebbe essere quello dello script di sotto, che si basa sul principio che i valori di primo tentativo delle 3 incognite intere positive maggiori di zero avvengano partendo da un numero alto (n=10, per esempio). Quando viene verificata la condizione della sommatoria nulla, il triplo ciclo si blocca mostrando la soluzione. Confermo, gila, hai aperto una interessante discussione. Cheers

Codice: Seleziona tutto

# ---- barattoli.py --------- (forum Ubuntu Italia, Python 2.6, 18.05.17) ---------
#
n = input("\n Valore iniziale intero delle 3 incognite [try 10]: ")
a=33
b=50
c=75
d=233
# 
j=n
k=n
#
for i in range (n,0,-1):
 somma= a*i + b*j + c*k -d 
 if (somma == 0): break
 
 for j in range (n,0,-1):
  somma= a*i + b*j + c*k -d
  if (somma == 0): break 
  
  for k in range (n,0,-1):
   somma= a*i + b*j + c*k -d 
   if (somma == 0): break

print "\n Equazione data: a*x + b*y + c*z -d = 0, con [a=33, b=50, c=75, d=233]"   	
print " Soluzione: (x,y,z)= ", i,j,k

# ------------ OUTPUT --------------
# Valore iniziale intero delle 3 incognite [try 10]: 10
#
# Equazione data: a*x + b*y + c*z -d = 0, con [a=33, b=50, c=75, d=233]
# Soluzione: (x,y,z)=  1 1 2
# ----------------------------------

[gila75]

Ecco, questa è la bozza di ciò che mi ero prefissato di fare:

Codice: Seleziona tutto

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<unistd.h>



int mcd(int min,int max, int tab[][4],int *n);
void min_max (int *a,int *b);
void stampa (int n,int tab[][4]);
int bez (int n,int tab[][4],int liquido);
void init_array(int tab[][4],int a,int b);
void riduci(int *a,int *b, int *liquido,int mcd);
int test(int mcd, int *l, int *f, int copy_l,int *n);
int risolvi (int p,int a, int b,int liquido,int mcd,int copy_l);


//***********************************************
// scambia numeri per trovare il massimo dei 2
//***********************************************
void min_max (int *a,int *b)
{
	int temp;
	if (*a<*b)
	{
		temp=*a;
		*a=*b;
		*b=temp;
	}
}

//***********************************************
// trova MCD metodo di Eulero
//***********************************************
int mcd(int min, int max,int tab[][4],int *n)
{
	int r = 1;
	int res;
	
	if (min == 0)
    	return max;
    else
    	while (r > 0)
		{
       		r = max % min;
			res=max/min;
        	max = min;
        	min = r;
			tab[*n+1][0]=min;
			tab[*n][1]=res;
			*n=(*n)+1;
		}
	
	return max;
}

//***********************************************
// test: se il liquido non è un multiplo dei
// 2 membri (75,33 nel mio) caso
// il risultato sarà frazionario e a me non va bene
//*************************************************
int test(int mcd, int *l, int *f, int copy_l,int *n)
{
	if  ( (*l%mcd)!=0)
	{	
		printf("cl %d: impossibile frazionario\n",*l);
		*f=*f+1;
		*l=copy_l-*f;
		*n=0;
		return 0;
	}
		
	return 1;
	
}

void riduci(int *a,int *b, int *liquido,int mcd)
{
	
	if ( (*liquido%mcd)==0 )
	{
		*a=*a/mcd;
		*b=*b/mcd;
		*liquido=*liquido/mcd;
		
		
	}
}

//***********************************************
// preparo l'array per il calcolo
// dei coefficienti di Bezout
//***********************************************
void init_array(int tab[][4],int a,int b)
{
	int r,c;
	for (r=0; r<50; r++)
	{
		for (c=0; c<4; c++)
			tab[r][c]=0;
	}
		
	tab[0][0]=a;
	tab[1][0]=b;
	tab[0][2]=1;
	tab[1][3]=1;
}
//***********************************************
// calcolo identità p di Bezout
//***********************************************
int bez (int n,int tab[][4], int liquido)
{
	int i;
	for (i=0; i<n; i++)
	{
		tab[i+2][2]=tab[i][2]-(tab[i+1][1]*tab[i+1][2]);
	}
	
	return tab[n-1][2]*liquido;
}




//***********************************************
// eventuale stampa per vedere la matrice
// che mi permette di vedere i passaggi
// e le identità di B.
//***********************************************
void stampa (int n,int tab[][4])
{
	int r,c;
	for (r=0; r<n; r++)
	{
		for (c=0; c<4; c++)
		{
			printf ("%d ", tab[r][c]);
		}
		puts("");
	}
	puts("-------------------");
}

//***********************************************
// calcola prima x, poi y
//***********************************************
	
int risolvi (int p,int a,int b,int liquido,int mcd,int copy_l)
{
	int res,x,y;
	
	res=p/b;	
	x=p-(res*b);
	y=(liquido-(a*x))/b;
	
	if (x>=0 && y>=0)
	{
		printf ("x(75cl)=%d y(33cl)=%d\n",x,y);
		printf ("LIQUIDO IMBOTTIGLIATO: cl %d\n", (a*x+b*y)*mcd);
		printf ("scarto: %d\n", (copy_l-(a*x*mcd+b*y*mcd)));
		return 1;
	}
	return 0;
	
}

	


int main (void)
{
	int a=75; //x
	int b=33; //y
	int liquido=141111;
	int copy_l=liquido;
    int aa=a;
	int bb=b;
	int res,p,x,t;
	int tab[50][4];
	int n;
	int f=0;
	
	while (1)
	{
		while(1)
		{
			min_max(&a,&b); 
			init_array(tab,a,b);
			res=mcd(a,b,tab,&n);
			t=test(res,&liquido,&f,copy_l,&n);
			if (t==1)
				break;
		}
			
		riduci (&a,&b,&liquido,res);
		p=bez(n,tab,liquido);
		
			
		x=risolvi(p,a,b,liquido,res,copy_l);
		if (x==1)
			break;
		if (x==0) 
		{
			++f;
			liquido=copy_l-f;
			a=aa;
			b=bb;
			n=0;
		}
				
				
	}
	return 0;
	
}

output:

Codice: Seleziona tutto

gila@gila-pc:~/Scrivania$ ./xx
x(75cl)=4 y(33cl)=4267
LIQUIDO IMBOTTIGLIATO: cl 141111
scarto: 0
gila@gila-pc:~/Scrivania$ 

51 cl input:
output:

Codice: Seleziona tutto

gila@gila-pc:~/Scrivania$ ./xx
cl 50: impossibile frazionario
cl 49: impossibile frazionario
cl 47: impossibile frazionario
cl 46: impossibile frazionario
cl 44: impossibile frazionario
cl 43: impossibile frazionario
cl 41: impossibile frazionario
cl 40: impossibile frazionario
cl 38: impossibile frazionario
cl 37: impossibile frazionario
cl 35: impossibile frazionario
cl 34: impossibile frazionario
x(75cl)=0 y(33cl)=1
LIQUIDO IMBOTTIGLIATO: cl 33
scarto: 18

la cosa bella però sarebbe poter gestire il tutto con un numero a piacere di incognite.
Se avete voglia di provare...così magari saltano fuori bug.

[BlueEyes]

Ciao Gila,
questo commento all'interno del tuo codice C mi lascia perplesso

//***********************************************
// test: se il liquido non è un multiplo dei
// 2 membri (75,33 nel mio) caso
// il risultato sarà frazionario e a me non va bene
//*************************************************

Nel senso che non è strettamente necessario che il totale del liquido sia condizionato dal MCD di 75 e 33, perché è il risultato della somma di 3 prodotti.

Per esempio, immaginiamo che il totale sia 3580 cl, che non è affatto un multiplo di 3, ma l'equazione ammette lo stesso una oppure, come un questo caso, più soluzioni, ricavate tramite il programmino riportato sotto.
Cheers

Codice: Seleziona tutto

Valore iniziale intero delle 3 incognite [try 100]: 100

 Equazione data: 33 * x +  50 * y +  75 * z -  3580  = 0

 Soluzione: (x,y,z)=  85 14 1
 Soluzione: (x,y,z)=  85 14 1
 Soluzione: (x,y,z)=  85 11 3
 Soluzione: (x,y,z)=  85 8 5
 Soluzione: (x,y,z)=  85 5 7
 Soluzione: (x,y,z)=  85 2 9
 Soluzione: (x,y,z)=  60 29 2
 Soluzione: (x,y,z)=  60 26 4
 Soluzione: (x,y,z)=  60 23 6
 Soluzione: (x,y,z)=  60 20 8
 Soluzione: (x,y,z)=  60 17 10
 Soluzione: (x,y,z)=  60 14 12
 Soluzione: (x,y,z)=  60 11 14
 Soluzione: (x,y,z)=  60 8 16
 Soluzione: (x,y,z)=  60 5 18
 Soluzione: (x,y,z)=  60 2 20
 Soluzione: (x,y,z)=  35 47 1
 Soluzione: (x,y,z)=  35 47 1
 Soluzione: (x,y,z)=  35 44 3
 Soluzione: (x,y,z)=  35 41 5
 Soluzione: (x,y,z)=  35 38 7
 Soluzione: (x,y,z)=  35 35 9
 Soluzione: (x,y,z)=  35 32 11
 Soluzione: (x,y,z)=  35 29 13
 Soluzione: (x,y,z)=  35 26 15
 Soluzione: (x,y,z)=  35 23 17
 Soluzione: (x,y,z)=  35 20 19
 Soluzione: (x,y,z)=  35 17 21
 Soluzione: (x,y,z)=  35 14 23
 Soluzione: (x,y,z)=  35 11 25
 Soluzione: (x,y,z)=  35 8 27
 Soluzione: (x,y,z)=  35 5 29
 Soluzione: (x,y,z)=  35 2 31
 Soluzione: (x,y,z)=  10 62 2
 Soluzione: (x,y,z)=  10 59 4
 Soluzione: (x,y,z)=  10 56 6
 Soluzione: (x,y,z)=  10 53 8
 Soluzione: (x,y,z)=  10 50 10
 Soluzione: (x,y,z)=  10 47 12
 Soluzione: (x,y,z)=  10 44 14
 Soluzione: (x,y,z)=  10 41 16
 Soluzione: (x,y,z)=  10 38 18
 Soluzione: (x,y,z)=  10 35 20
 Soluzione: (x,y,z)=  10 32 22
 Soluzione: (x,y,z)=  10 29 24
 Soluzione: (x,y,z)=  10 26 26
 Soluzione: (x,y,z)=  10 23 28
 Soluzione: (x,y,z)=  10 20 30
 Soluzione: (x,y,z)=  10 17 32

Codice Python

Codice: Seleziona tutto

# ---- barattoli2.py --------- (forum Ubuntu Italia, Python 2.6, 18.05.17) ---------
#       scandaglia piu' soluzioni, se ce ne sono !!
n = input("\n Valore iniziale intero delle 3 incognite [try 10]: ")
a=33
b=50
c=75
d=3580
# 
j=n
k=n
#
print "\n Equazione data:",a,"* x + ",b,"* y + ",c,"* z - ",d," = 0\n"

for i in range (n,0,-1):
 somma= a*i + b*j + c*k -d 
 if (somma == 0): 
  print " Soluzione: (x,y,z)= ", i,j,k
  
 for j in range (n,0,-1):
  somma= a*i + b*j + c*k -d
  if (somma == 0): 
   print " Soluzione: (x,y,z)= ", i,j,k
  
  for k in range (n,0,-1):
   somma= a*i + b*j + c*k -d 
   if (somma == 0): 
    print " Soluzione: (x,y,z)= ", i,j,k

print "\n -------- Fine della scansione --------"
#

[gila75]

Per esempio, immaginiamo che il totale sia 3580 cl, che non è affatto un multiplo di 3, ma l'equazione ammette lo stesso una oppure, come un questo caso, più soluzioni, ricavate tramite il programmino riportato sotto.

Certo, ma io mi riferisco per ora solo a 75,33 (mcd 3). Mentre tu hai fatto una prova con 33,75,50 (mcd 1) per quello.
Con 75 e 33, se il liquido non è divisibile per l'mcd (3 in questo caso), automaticamente x o y o entrambe saranno una frazione.
Mentre con liquido divisibile per mcd sicuramente hai soluzioni intere ma non è detto che siano per forza
positive.
Esempio 303 non hai soluzioni intere (con 75 e 33) ma devi scalare fino a 300.

Devo vedere bene il tuo programma. Non ho capito bene, sembrerebbe un brute force? Cerca e prova finchè (se puoi) trova?
Potrebbe andare bene, anche se m'interessava capire le diofantee, per questo ho scelto questa strada.

[BlueEyes]

...sembrerebbe un brute force...

Sì, è proprio così. E' ciò che l'informatica permette di fare, perché per sua natura non sviluppa "dimostrazioni matematiche", ma consente di effettuare, in qualche millisecondo, verifiche di calcolo altrimenti impossibili.

Ed è quello che ho fatto io per risolvere il tuo quesito iniziale, mentre con il tuo procedimento tu cerchi di "adeguare" il calcolo numerico ad una dimostrazione matematica di tipo diofanteo. Seguirò con cura i tuoi sviluppi.

Aggiungo solo che la cosiddetta "brute force", che beninteso non ha nulla di elegante rispetto al fascino di una dimostrazione matematica, viene spesso usata per testare i tempi di esecuzione di algoritmi matematici, oppure, per restare
in tema, a "verificare" l'ultimo teorema di Fermat, la _non_ esistenza di terne cubiche: x^3+y^3=z^3, come risulta [partendo per es. da n=1000] dal programmino di sotto, analogo a quello dei barattoli

Ciao, e alla prossima

PS: Sostituendo i quadrati ai cubi, invece, si ottengono le terne pitagoriche

Spoiler

Mostra

Codice: Seleziona tutto

# ---- fermat.py --------- (Python 2.6, 19.05.17) ---------
#    (terne cubiche)
n = input("\n Valore iniziale intero delle 3 incognite [try 500]: ")
# 
j=n
k=n
#
print "\n ------ Terne cubiche: x^3 + y^3 = z^3 -------\n"

for i in range (n,0,-1):
 somma= i**3 + j**3 - k**3
 if (somma == 0): 
  print " (x,y,z)= ", i,j,k
  
 for j in range (n,0,-1):
  somma= i**3 + j**3 - k**3
  if (somma == 0): 
   print " (x,y,z)= ", i,j,k
  
  for k in range (n,0,-1):
   somma= i**3 + j**3 - k**3 
   if (somma == 0): 
    print " (x,y,z)= ", i,j,k

print "\n -------- Fine della scansione --------"
# ------------ OUTPUT --------------
#
#
# Valore iniziale intero delle 3 incognite [try 1000]: 1000
#
# ------ Terne cubiche: x^3 + y^3 = z^3 -------
#
#
# -------- Fine della scansione --------  <<< nessun risultato, appunto

[BlueEyes]

Attenzione, Gila, il problemino "diofanteo" del post d'apertura potrebbe anche presentarsi come quello di figura, ripreso dal libro online (di cui si parla qualche post più su) "Introduzione alle Equazioni Diofantee", autore Luigi Verolino, il link per scaricarlo è questo http://www.ateneapolieditore.it/ebook/l ... fantee.pdf, capitolo 'Esercizi non svolti', pag. 83.

Qui i coefficienti _non_ sono interi, ma frazionari, ed allora la tua ricerca dei MCD non andrebbe più bene. Quindi non vedo altro metodo di soluzione che la "rozza" forza bruta, che anche l'autore del libro avrebbe fatto bene ad usare, visto che egli dà un'unica soluzione, invece di tante. Eccole:

Spoiler

Mostra

Codice: Seleziona tutto

 Valore iniziale intero delle 3 incognite [try 20]: 20

 Equazione data: 0.7 * x +  2.0 * y +  0.3 * z -  20.0  = 0

 Soluzione: (x,y,z)=  18 1 18
 Soluzione: (x,y,z)=  17 3 7
 Soluzione: (x,y,z)=  16 2 16
 Soluzione: (x,y,z)=  15 4 5
 Soluzione: (x,y,z)=  14 3 14
 Soluzione: (x,y,z)=  13 5 3
 Soluzione: (x,y,z)=  12 4 12
 Soluzione: (x,y,z)=  11 6 1
 Soluzione: (x,y,z)=  11 6 1
 Soluzione: (x,y,z)=  10 5 10
 Soluzione: (x,y,z)=  9 4 19
 Soluzione: (x,y,z)=  8 6 8
 Soluzione: (x,y,z)=  7 5 17
 Soluzione: (x,y,z)=  6 7 6
 Soluzione: (x,y,z)=  5 6 15
 Soluzione: (x,y,z)=  4 8 4
 Soluzione: (x,y,z)=  3 7 13
 Soluzione: (x,y,z)=  2 9 2
 Soluzione: (x,y,z)=  1 8 11   <<< ------- il libro mostra solo questo risultato

 -------- Fine della scansione --------

Ciao

[gila75]

Sono un po' di fretta, dovrei leggere bene, magari più tardi ho tempo.
Nel caso es:
33x+75=100
mcd 33 e 75 =3
l'mcd di 100 non è 3 quindi devo scalare necessariamente a 99...ecc.
quando il liquido è mcd di 3 e prevede solo risultati positivi mi fermo.
Il mio programma in definitiva fa (messo a schemi)
* calcola mcd (75,33)
* controlla se il liquido è un multiplo di mcd
-no?---> scala di 1 cl e rifai;
-si?
* riduci in forma più semplice: 75x+33y=99 che equivale a 25x+11y=33
*calcola identità di Bezout
* trova x e y ed eventuale scarto
-entrambe positive?
-si----> fine
no?---->scala di 1 cl e rifai

Equazione data: 0.7 * x + 2.0 * y + 0.3 * z - 20.0 = 0

credo sia equivalente a 7x+ 20y+3z-200=0