Come trovare numero minimo resistenze per arrivare ad un dato valore?

Il 07/07/2011 16.51, RobertoA ha scritto:

ciao non è più semplice 1200+47+10+10

ciao primula

se è un calcolo puramente teorico nulla, altrimenti conta eccome sapere dove finirà il calore e come dimensionare le singole resistenze.

ok

allora si scartano tutte le combinazioni che ci si avvicinano soltanto, mi pare una differenza fondamentale, è ovvio che non esistendo resistori così perfetti il calcolo non avrà alcuna utilità pratica.

"primula" ha scritto nel messaggio news:4e15d79a$0$44203$ snipped-for-privacy@reader1.news.tin.it...

Si, certo e' piu' semplice Il mio era solo un esempio, non credo esistano resistenze da 2534 ohm

"Giggino er bullo" ha scritto nel messaggio news: snipped-for-privacy@4ax.com...

Esatto Il mio interesse e' volto al comprendere il ragionamento per risolvere analiticamente il problema 'a provando' non vale anche perche' mi sembrano fantastiliardi di combinazioni, anche con poche resistenze Ad esempio, se volessi ottenere 1267 ohm, e volessi provare con un parallelo tra due resistenze, la logica mi porterebbe a prendere la resistenza1 leggermente maggiore del 1267 e poi, partendo dala resistenza piu' alta della serie scelta, supponiamo la E12, tentare il parallelo con la resistenza2 Mano a mano che scendo coi valori, il parallelo dovrebbe avvicinarsi sempre piu' al valore desiderato Appena il parallelo arriva ad un valore inferiore ai 1267, allora tengo buono il parallelo precedente, che risultera' di valore ommico leggermente superiore ai 1267 Con la stessa logica, aggiungerei una terza resistenza, partendo dal valore piu' alto e proverei con tutti i valori a scendere fino ad arrivare ad un valore immediatamente inferiore ai 1267, terrei buona la resistenza3 precedente E cosi via Gia' con poche resistenze, i conteggi mi sembrano davvero molto elevati e comunque, anche raggiunto il valore desiderato di 1267 ohm, non e' detto che quelle resistenze siano il numero minimo scelto tra la serie E12 Magari esiste una qualche combinazione che realizza il 1267 ohm con numero inferiore di resistenze Ciao e grazie RobertoA

se sei interessato a questo genere di problemi ti consiglio la "Ricerca Operativa", per inciso questa classe di problemi si risolve proprio per tentativi, chiaramente questi tentativi in genere sono orientati e non casuali o del tutto esaustivi.

questa logica ti fa convergere al valore esatto della resistenza ma non alla soluzione minima, tra l'altro esiste almeno una soluzione banale formata da 1 resistenza da 1K, 2 resistenze da 100, 6 resistenze da 10 e

7 resistenze da 1 Ohm, banale perche' sempre realizzabile e senza necessita' di testare la soluzione!

bravo il punto e' tutto qui, non converge alla soluzione ottima ( ottima secondo i tuoi criteri cioe' col numero minimo di elementi )

cerca in rete per Branch & Bound ( vado a memoria )

Io farei nello stesso modo in cui si trasforma un numero in binario. Da 1267 sottrai il valore inferiore piu' prossimo:

1267-1k2=67 Ora ci si potrebbe accontentare di aggiungere una 68 Ohm. tot:1k2+68 Altrimenti il valore inferiore piu' prossimo e' 56: 67-56=11 11-10=1 tot:1k2+56+10+1.

Per quanto riguarda il parallelo, "a mano" la vedo dura, ci vorrebbe un programmino. A meno che non stamparsi (per averle sottomano) tutte le combinazioni di parallelo tra 2 valori della serie E12, dovrebbero essere 72 valori e utilizzarli come estensione della E12 per il metodo sopra indicato.

mandi

La soluzione banale, essendo che la E12 dispone solo di resistenze da 10 ohm in su, per fare le sette resistenze da 1 ohm potrei usare 7 paralleli ognuno composto da 10 resistenze da 10 ohm l'una In totale ottanta resistenze per la soluzione banale E' questa l'ottimizzazione che vorrei realizzare, diminuire il numeo di resistenze, fermo restando l'ottenimento del valore resistivo finale richiesto Ciao e grazie RobertoA

Gia', le quattro resistenze andrebbero anche bene per ottenere il valore richiesto Ma come fare per sapere se esiste anche una rete a tre resistenze che arrivi ai 1267 ? E a due resistenze? Ciao e grazie RobertoA

"RobertoA" ha scritto nel messaggio news:4e15e93a$ snipped-for-privacy@newsgate.x-privat.org...

Me la sono fregata, ci sono anche le 1 ohm Ovviamente era il ragionamento che tenevo a sottolineare, quindi come sapere se esista una rete con numero minore di resistori che ottenga la stessa resistenza? Ciao e grazie RobertoA

RobertoA ha scritto:

Io ho scritto un programmino, non ottimizzato, che analizza tutte le combinazioni in serie e in parallelo di 2 e 3 resistenze della serie E12, il risultato in questo caso e' che con 3 resistenze si hanno soluzioni solo quando le 3 resistenze sono in serie:

(27 + 560 + 680) ohm e (47 + 220 + 1000) ohm

Allora non ci sono soluzioni.

Ciao

--
Giorgio Bibbiani

bravo! e comunque ti hanno gia' passato soluzioni "banali" non ottime ( secondo il criterio di minimo uso ) migliori della mia

ti ripeto il problema che cerchi di risolvere si affronta con le tecniche della ricerca operativa ed e' in quell'ambito che devi ( puoi ) indagare

tieni conto che anche la ricerca operativa non ti fornisce lo specifico algoritmo per la soluzione del tuo problema ma una serie di tecniche di risoluzione per problemi di ricerca in insiemi molto vasti

P.S: il problema ( non la soluzione ) non e' assolutamente banale, ed e' molto probabile che la risposta che avrai dalla ricerca operativa e' sub-ottima

Il 07/07/2011 18.45, RobertoA ha scritto:

E' il tipico problema combinatorio detto dello Zaino o Knapsack problem. Se vuoi studiare:

Saluti, J.

Si prende il valore superiore più prossimo e si trova l'altra:

1500 // x = 1267 => x = 1500*1267/(1500-1267) ~= 8200 1500 // 8200 = 1268

così procedendo il passo successivo è

1500 // 8200 // 1M5 = 1267

Naturalmente è un divertimento matematico, perché in pratica le resistenze da 10, 1 e 1M5 non hanno senso visto che parliamo di tolleranze del 10%. E anche quelle da 68 e 8200 hanno senso solo col conforto di un tester ben preciso.

"RobertoA" :

Posto che ci sono sicuramente soluzioni più efficienti, con le normali potenze di calcolo a disposizione su un PC si può lavorare in maniera brutalmente esaustiva con soddisfazione e semplicità.

Prendi ad esempio un vettore con sette decadi di resistenze E12 (da 1 a

8M2): sono 84 valori.

Al passo successivo costruisci un vettore con tutte le combinazioni di serie e parallelo a due a due: sono 2*84^2 = 14112 valori.

Poi consideri quelle con tre, quindi le combinazioni del primo con il secondo vettore: 2*14112*84 = 2371152 valori.

Poi con quattro: le combinazioni del secondo con se stesso e del primo col terzo: 2*14112^2+2*84*2371152 = 796 milioni e passa. Qui siamo al limite delle possibilità di un comune calcolatore, il vettore occupa quasi 4GB.

In realtà, se ad ogni passo ti curi almeno di ordinare e scartare i valori uguali il totale è molto inferiore, e tutte le combinazioni di quattro resistenze sono poco più di cinquanta milioni, alla portata di qualunque PC, con una distanza relativa fra l'una e l'altra che è sempre inferiore al 5%, per i 48 milioni di valori centrali è inferiore a 2e-4 e in media è inferiore a 6e-6.

Questo è il programmillo in Octave che genera il vettore r con tutti i valori:

clear all r12=[1 1.2 1.5 1.8 2.2 2.7 3.3 3.9 4.7 5.6 6.8 8.2]; r127 = single(r12'*10.^(0:6)); r1271 = r127(:); [r1 r2]=meshgrid(r1271, r1271); r1272=unique([(r1+r2)(:); (1./(1./r1+1./r2))(:)]); [r1 r2]=meshgrid(r1271, r1272); r1273=unique([(r1+r2)(:); (1./(1./r1+1./r2))(:)]); [r1 r2]=meshgrid(r1272, r1272); r1274=unique([(r1+r2)(:); (1./(1./r1+1./r2))(:)]); [r1 r2]=meshgrid(r1271, r1273); r1274=unique([r1274; (r1+r2)(:); (1./(1./r1+1./r2))(:)]); clear r1 r2 r = unique([r1271;r1272;r1273;r1274]);

Limitatamente alla realizzazione con collegamento in serie, l'algo potrebbe essere:

--- ' Funzione rientrante. ' - Lo scopo =E8 ottenere la REq richiesta con il minimo numero di resistenze. ' - Procede con valori standard decrescenti. ' -- Aggiunge alla REq gi=E0 formata il valore standard uguale all'ultimo aggiunto. ' -- Se la REq ottenuta =E8 superiore alla REq richiesta, prova con il valore standard inferiore. ' -- Se ottiene la REq richiesta, salva la soluzione (numero di resistenze e valori) e ritorna. ' -- Se la REq ottenuta =E8 inferiore alla REq richiesta, ' --- Se manca solo una resistenza a raggiungere il numero impiegato nella soluzione gi=E0 ottenuta, ritorna. ' --- Se il numero di resistenze mancanti a raggiungere quello impiegato nella soluzione gi=E0 ottenuta, ' moltiplicato per l'ultimo valore standard aggiunto =E8 inferiore al valore mancante a raggiungere ' la REq richiesta, ritorna ' --- Altrimenti richiama se stessa ' Quando ritorna dalla prima chiamata, l'ultima soluzione salvata impiega il minimo numero di resistenze.

---

Qui il progetto e l'eseguibile vb6:

c38a131f4a495dd902.html

Ciao. lucky

La formula inversa del parallelo, hai ragione, a parte sul "divertimento" matematico :-)

mandi

Francesco Potort=C3=AC ha scritto:

Oooo, grazie :) Questo algoritmo funziona bene, con max 3 resistenze si=20 ottengono tutti i valori della serie E24 all'1%, e max 4 per (credo)=20 qualsiasi altro valore sempre all'1% di tolleranza.

Ad esempio una 13k la fa con un parallelo di 15k e 100k con un errore=20 dello 0.33%

13000.0

---> 15000 err: 0.153846153846

---> 100000 req: 13043.4782609 err: 0.00334448160535

Python buttato giu' al volo:

#----------------------------------------------------------- RESISTENZE =3D ( 1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6, 6.8, 8.2, 10, 12, 15, 18, 22, 27, 33, 39, 47, 56, 68, 82, 100, 120, 150, 180, 220, 270, 330, 390, 470, 560, 680, 820, 1000, 1200, 1500, 1800, 2200, 2700, 3300, 3900, 4700, 5600, 6800, 8200, 10000, 12000, 15000, 18000, 22000, 27000, 33000, 39000, 47000, 56000, 68000, 82000, 100000, 120000, 150000, 180000, 220000, 270000, 330000, 390000, 470000, 560000, 680000, 820000, 1000000, 1200000, 1500000, 1800000, 2200000, 2700000, 3300000, 3900000, 4700000, 5600000, 6800000, 8200000, 10000000, 12000000, 15000000, 18000000, 22000000, 27000000, 33000000, 39000000, 47000000, 56000000, 68000000, 82000000 ) #----------------------------------------------------------- def trovaSup(R): for X in RESISTENZE: if X>=3DR: return X #----------------------------------------------------------- RDES =3D 13000.0 # resistenza desiderata print RDES TOLL =3D 1.0 # tolleranza 1% R =3D trovaSup(RDES) print "--->",R ERR =3D abs(1.0 - R/RDES) print "err:",ERR while ERR>(TOLL/100.0): RP =3D 1.0 / ( 1.0 / RDES - 1.0 / R) RP =3D trovaSup(RP) print "--->",RP R =3D 1.0 / ( 1.0 / RP + 1.0 / R) print "req:",R ERR =3D abs(1.0 - R/RDES) print "err:",ERR #-----------------------------------------------------------

Limitatamente alla realizzazione con collegamento in serie, l'algo potrebbe essere:

--- ' Funzione rientrante. ' - Lo scopo è ottenere la REq richiesta con il minimo numero di resistenze. ' - Procede con valori standard decrescenti. ' -- Aggiunge alla REq già formata il valore standard uguale all'ultimo aggiunto. ' -- Se la REq ottenuta è superiore alla REq richiesta, prova con il valore standard inferiore. ' -- Se ottiene la REq richiesta, salva la soluzione (numero di resistenze e valori) e ritorna. ' -- Se la REq ottenuta è inferiore alla REq richiesta, ' --- Se manca solo una resistenza a raggiungere il numero impiegato nella soluzione già ottenuta, ritorna. ' --- Se il numero di resistenze mancanti a raggiungere quello impiegato nella soluzione già ottenuta, ' moltiplicato per l'ultimo valore standard aggiunto è inferiore al valore mancante a raggiungere ' la REq richiesta, ritorna ' --- Altrimenti richiama se stessa ' Quando ritorna dalla prima chiamata, l'ultima soluzione salvata impiega il minimo numero di resistenze.

---

Qui il progetto e l'eseguibile vb6:

Ciao. lucky

------------------------

Eccola qua la soluzione Ciao e grazie RobertoA

Claudio_F :

Come dicevo in altro messaggio, con una ricerca esaustiva ho visto che con combinazioni serie e parallelo di quattro resistenze si ottengono tolleranze medie di 1e-6 sulla scala da 1 a 82M. In realtà ora vedo che già con combinazioni serie e parallelo di sole tre resistenze si ottiene un errore relativo medio di 2e-6, quindi è ancora più semplice di quanto mi aspettassi.

Ora manca trovare un algoritmo semplice per trovare la combinazione serie - parallelo di tre resistenze più vicina al desiderato, senza cui si può sempre andare sull'esaustivo, che con sole tre resistenze è abbordabilissimo.