Bonjour,
Je fais appel à ce forum afin de bénéficier d'un point de vue extérieur. L'objectif de ce sujet est de chercher une routine dans ma démarche, me permettant de simplifier considérablement mon code.
Pour mon problème, je pars de données de bases qui sont : un nom d'équipement, un débit, une probabilité d'occurence. Les évènements sont stockés dans un array, en commençant par les évènements simple (un équipement seul) :
Puis ma macro va lister toutes les paires possibles (pas de doublons, l'ordre n'importe pas), puis toutes les triplettes, puis tout les quatuor etc.... et à chaque évènements, il va calculer le débit résultant (somme des débits individuels) et la probabilité de l'évènements (produits des probabilités individuelles des évènements pris en compte).
Préalablement, je calcul combien d'évènements vont être présent et je redimensionne mon array en conséquent :
(Rappel : C = n! / ( p! * (n-p)!)
Enfin, je construis une routine qui s'étends au fur et à mesure que la marco avance :
1er niveau de bouclage, on forme des doubles :
je re-dimensionne mon array, le bout de code est le même, je ne vais pas le remettre.
Puis 2eme niveau de bouclage, on fait des triplettes :
je re-dimensionne mon array, le bout de code est le même, je ne vais pas le remettre.
Puis 3eme niveau de bouclage, on fait des quadriplets :
....
bref, je suis aller jusqu'au 7 ème niveau de bouclage (8 équipements simultanés) :
Mon problème est que je suis limité par la taille de l'array (par ma quantité de RAM = stockage array), celle-ci va au moins à 2 millions de lignes, ce qui pour mon exemple actuelle correspond au 4ème niveau.
Je cherche donc à effectuer mes calculs au fur et à mesure à la fin de chaque "toolcross", et à n'avoir qu'une seule macro dont le nombre de toolcross, et donc le nombre de boucle for incrémentées les unes dans les autres, est définie au début de la macro (en fonction du nombre de tool-cross auquel l'utilisateur se situe, passage par une boite de dialogue).
Donc il faut que j'arrive à écrire ma macro pour que le nombre d'imbrication soit variable en fonction du paramètre que l'utilisateur fourni à la macro.
Je suis ouvert à toutes vos suggestions !
Cordialement,
Jérôme
MAJ :
Résolu
Je fais appel à ce forum afin de bénéficier d'un point de vue extérieur. L'objectif de ce sujet est de chercher une routine dans ma démarche, me permettant de simplifier considérablement mon code.
Pour mon problème, je pars de données de bases qui sont : un nom d'équipement, un débit, une probabilité d'occurence. Les évènements sont stockés dans un array, en commençant par les évènements simple (un équipement seul) :
Code:
dblNbTool = Application.WorksheetFunction.CountA(wsDataSimu.Range("A:A")) - 1
With wsPOccurenceSimu
.Range("A1").Value = "Q (L/min)"
.Range("B1").Value = "P Occurence"
.Range("C1").Value = "nom des tools croisés"
intNbToolCross = 0 'les évènements sont simple (1équipement)
lngPosition = 0 'ma position dans l'array de stockage
lngSizeArray = dblNbTool 'la taille initiale de l'array est définie par
'le nombre initiale d'équipement
ReDim arrDataCross(3, lngSizeArray)
For intTool = 1 To dblNbTool - intNbToolCross 'je stocke les données dans l'array
arrDataCross(0, lngPosition) = wsDataSimu.Range("C1").Offset(intTool, 0).Value
arrDataCross(1, lngPosition) = wsDataSimu.Range("K1").Offset(intTool, 0).Value
arrDataCross(2, lngPosition) = wsDataSimu.Range("B1").Offset(intTool, 0).Value
lngPosition = lngPosition + 1
Next intToolPuis ma macro va lister toutes les paires possibles (pas de doublons, l'ordre n'importe pas), puis toutes les triplettes, puis tout les quatuor etc.... et à chaque évènements, il va calculer le débit résultant (somme des débits individuels) et la probabilité de l'évènements (produits des probabilités individuelles des évènements pris en compte).
Préalablement, je calcul combien d'évènements vont être présent et je redimensionne mon array en conséquent :
(Rappel : C = n! / ( p! * (n-p)!)
Code:
intNbToolCross = 0
Code:
i = 1
dblFactorielleNP = 1
While (i <= (dblNbTool - intNbToolCross - 1))
dblFactorielleNP = dblFactorielleNP * i
i = i + 1
Wend
i = 1
dblFactorielleP = 1
While (i <= (intNbToolCross + 1))
dblFactorielleP = dblFactorielleP * i
i = i + 1
Wend
i = 1
dblFactorielleN = 1
While (i <= (dblNbTool))
dblFactorielleN = dblFactorielleN * i
i = i + 1
Wend
dblFactorielle = dblFactorielleN / (dblFactorielleP * dblFactorielleNP)
lngSizeArray = lngSizeArray + dblFactorielle 'la taille initiale de mon array augmente du nombre
'd'évènements à venir
ReDim Preserve arrDataCross(3, lngSizeArray)Enfin, je construis une routine qui s'étends au fur et à mesure que la marco avance :
1er niveau de bouclage, on forme des doubles :
Code:
intNbToolCross = 1
Code:
intTool = 1
j = 2
For i = 1 To dblNbTool - intNbToolCross
For jb = j To dblNbTool
arrDataCross(0, lngPosition) = _
wsDataSimu.Range("C1").Offset(i, 0).Value + _
wsDataSimu.Range("C1").Offset(jb, 0).Value
arrDataCross(1, lngPosition) = _
wsDataSimu.Range("K1").Offset(i, 0).Value * _
wsDataSimu.Range("K1").Offset(jb, 0).Value
arrDataCross(2, lngPosition) = _
CStr(wsDataSimu.Range("B1").Offset(i, 0).Value) & " " & _
CStr(wsDataSimu.Range("B1").Offset(jb, 0).Value)
lngPosition = lngPosition + 1
intTool = intTool + 1
Next jb
j = j + 1 '
Next ije re-dimensionne mon array, le bout de code est le même, je ne vais pas le remettre.
Puis 2eme niveau de bouclage, on fait des triplettes :
Code:
intNbToolCross = 2
Code:
intTool = 1
j = 2
k = 3
For i = 1 To (dblNbTool - intNbToolCross)
For jb = j To dblNbTool
For kb = k To dblNbTool
arrDataCross(0, lngPosition) = _
wsDataSimu.Range("C1").Offset(i, 0).Value + _
wsDataSimu.Range("C1").Offset(jb, 0).Value + _
wsDataSimu.Range("C1").Offset(kb, 0).Value
arrDataCross(1, lngPosition) = _
wsDataSimu.Range("K1").Offset(i, 0).Value * _
wsDataSimu.Range("K1").Offset(jb, 0).Value * _
wsDataSimu.Range("K1").Offset(kb, 0).Value
arrDataCross(2, lngPosition) = _
CStr(wsDataSimu.Range("B1").Offset(i, 0).Value) & " " & _
CStr(wsDataSimu.Range("B1").Offset(jb, 0).Value) & " " & _
CStr(wsDataSimu.Range("B1").Offset(kb, 0).Value)
lngPosition = lngPosition + 1
intTool = intTool + 1
Next kb
k = k + 1
Next jb
j = j + 1
k = j + 1
Next ije re-dimensionne mon array, le bout de code est le même, je ne vais pas le remettre.
Puis 3eme niveau de bouclage, on fait des quadriplets :
Code:
intNbToolCross = 3
Code:
j = 2
k = 3
l = 4
For i = 1 To (dblNbTool - intNbToolCross)
For jb = j To dblNbTool
For kb = k To dblNbTool
For lb = l To dblNbTool
arrDataCross(0, lngPosition) = _
wsDataSimu.Range("C1").Offset(i, 0).Value + _
wsDataSimu.Range("C1").Offset(jb, 0).Value + _
wsDataSimu.Range("C1").Offset(kb, 0).Value + _
wsDataSimu.Range("C1").Offset(lb, 0).Value
arrDataCross(1, lngPosition) = _
wsDataSimu.Range("K1").Offset(i, 0).Value * _
wsDataSimu.Range("K1").Offset(jb, 0).Value * _
wsDataSimu.Range("K1").Offset(kb, 0).Value * _
wsDataSimu.Range("K1").Offset(lb, 0).Value
arrDataCross(2, lngPosition) = _
CStr(wsDataSimu.Range("B1").Offset(i, 0).Value) & " " & _
CStr(wsDataSimu.Range("B1").Offset(jb, 0).Value) & " " & _
CStr(wsDataSimu.Range("B1").Offset(kb, 0).Value) & " " & _
CStr(wsDataSimu.Range("B1").Offset(lb, 0).Value)
lngPosition = lngPosition + 1
Next lb
l = l + 1
Next kb
k = k + 1
l = k + 1
Next jb
j = j + 1
k = j + 1
l = k + 1
Next i....
bref, je suis aller jusqu'au 7 ème niveau de bouclage (8 équipements simultanés) :
Code:
intNbToolCross = 7
Code:
j = 2
k = 3
l = 4
m = 5
n = 6
o = 7
p = 8
For i = 1 To (dblNbTool - intNbToolCross)
For jb = j To dblNbTool
For kb = k To dblNbTool
For lb = l To dblNbTool
For mb = m To dblNbTool
For nb = n To dblNbTool
For ob = o To dblNbTool
For pb = p To dblNbTool
arrDataCross(0, lngPosition) = _
wsDataSimu.Range("C1").Offset(i, 0).Value + _
wsDataSimu.Range("C1").Offset(jb, 0).Value + _
wsDataSimu.Range("C1").Offset(kb, 0).Value + _
wsDataSimu.Range("C1").Offset(lb, 0).Value + _
wsDataSimu.Range("C1").Offset(mb, 0).Value + _
wsDataSimu.Range("C1").Offset(nb, 0).Value + _
wsDataSimu.Range("C1").Offset(ob, 0).Value + _
wsDataSimu.Range("C1").Offset(pb, 0).Value
arrDataCross(1, lngPosition) = _
wsDataSimu.Range("K1").Offset(i, 0).Value * _
wsDataSimu.Range("K1").Offset(jb, 0).Value * _
wsDataSimu.Range("K1").Offset(kb, 0).Value * _
wsDataSimu.Range("K1").Offset(lb, 0).Value * _
wsDataSimu.Range("K1").Offset(mb, 0).Value * _
wsDataSimu.Range("K1").Offset(nb, 0).Value * _
wsDataSimu.Range("K1").Offset(ob, 0).Value * _
wsDataSimu.Range("K1").Offset(pb, 0).Value
arrDataCross(2, lngPosition) = _
CStr(wsDataSimu.Range("B1").Offset(i, 0).Value) & " " & _
CStr(wsDataSimu.Range("B1").Offset(jb, 0).Value) & " " & _
CStr(wsDataSimu.Range("B1").Offset(kb, 0).Value) & " " & _
CStr(wsDataSimu.Range("B1").Offset(lb, 0).Value) & " " & _
CStr(wsDataSimu.Range("B1").Offset(mb, 0).Value) & " " & _
CStr(wsDataSimu.Range("B1").Offset(nb, 0).Value) & " " & _
CStr(wsDataSimu.Range("B1").Offset(ob, 0).Value) & " " & _
CStr(wsDataSimu.Range("B1").Offset(pb, 0).Value)
lngPosition = lngPosition + 1
Next pb
p = p + 1
Next ob
o = o + 1
p = o + 1
Next nb
n = n + 1
o = n + 1
p = o + 1
Next mb
m = m + 1
n = m + 1
o = n + 1
p = o + 1
Next lb
l = l + 1
m = l + 1
n = m + 1
o = n + 1
p = o + 1
Next kb
k = k + 1
l = k + 1
m = l + 1
n = m + 1
o = n + 1
p = o + 1
Next jb
j = j + 1
k = j + 1
l = k + 1
m = l + 1
n = m + 1
o = n + 1
p = o + 1
Next iMon problème est que je suis limité par la taille de l'array (par ma quantité de RAM = stockage array), celle-ci va au moins à 2 millions de lignes, ce qui pour mon exemple actuelle correspond au 4ème niveau.
Je cherche donc à effectuer mes calculs au fur et à mesure à la fin de chaque "toolcross", et à n'avoir qu'une seule macro dont le nombre de toolcross, et donc le nombre de boucle for incrémentées les unes dans les autres, est définie au début de la macro (en fonction du nombre de tool-cross auquel l'utilisateur se situe, passage par une boite de dialogue).
Donc il faut que j'arrive à écrire ma macro pour que le nombre d'imbrication soit variable en fonction du paramètre que l'utilisateur fourni à la macro.
Je suis ouvert à toutes vos suggestions !
Cordialement,
Jérôme
MAJ :
Résolu
Dernière édition:
