Discussion :

[ESYCOME]

Bonjour,

Je résume mon problème par une fonction plus basique* (ci-dessous): je cherche à connaitre le min de ma fonction "calcul" ainsi que les variables associées:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
calcul<-function(A,B,C,ad){
 
#calcul des 4 petites fonctions
sub=A*0.12+2
dej=B*111-33
arg=C-12
 
if(ad=="q"){
  b=33
} else if (ad=="s"){
  b=22
}else if(ad=="d"){
  b=14
}
zer=b*33+1
 
#total des 4 petites fonctions
 
total=sub+dej+arg+zer
return(total)
}
 
#exemple de calcul 
calcul(10,20,30,"q")

Mes variables peuvent prendre les valeurs suivantes
A: nombre entier entre 10 et 100
B:nombre entier entre 10 et 100
C: nombre entier entre 10 et 100
ad: q,s, ou d

Je cherche à jouer(/calculer) toutes les possibilités de la fonction "calcul" pour connaitre la meilleure combinaison pour que mon "total" soit au minimum et récupérer les variables.
par exemple mon résultat idéal serait:
Le min de votre fonction "calcul" est "2201" avec la combinaison A=33, B+44, C=21 et ad=s

J'ai beaucoup chercher et je ne trouve pas de fonction min avec plusieurs variables(même avec nlminb)
je vous remercie de votre aide


*ma fonction de base fait plus de 300 ligne et fait appel à des tableaux. Ce qui ne rentre pas dans cette problématique

[statnmap]

Bonjour,

En créant un tableau qui contient toutes les combinaisons possibles des 3 variables, vous pouvez appliquer le calcul à chacune et retrouver la valeur la plus petite.
Selon le nombre de combinaisons, vous devez avoir la RAM suffisante...
De cette manière:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
library(dplyr)
library(tidyr)
 
calcul<-function(A,B,C,ad){
 
  #calcul des 4 petites fonctions
  sub=A*0.12+2
  dej=B*111-33
  arg=C-12
 
  if(ad=="q"){
    b=33
  } else if (ad=="s"){
    b=22
  }else if(ad=="d"){
    b=14
  }
  zer=b*33+1
 
  #total des 4 petites fonctions
 
  total=sub+dej+arg+zer
  return(total)
}
 
#exemple de calcul
calcul(10,20,30,"q")
#> [1] 3298.2
 
# Creer toutes les combinaisons
tte_combinaisons <- expand_grid(
  A = 10:100,
  B = 10:100,
  C = 10:100
)
# Appliquer la fonction à toutes les combinaisons
# Re-ordonner de la plus petite à la plus grande
tte_combinaisons %>% 
  mutate(resultat = calcul(A, B, C, ad = "q")) %>% 
  arrange(resultat)
#> # A tibble: 753,571 x 4
#>        A     B     C resultat
#>    <int> <int> <int>    <dbl>
#>  1    10    10    10    2168.
#>  2    11    10    10    2168.
#>  3    12    10    10    2168.
#>  4    13    10    10    2169.
#>  5    14    10    10    2169.
#>  6    15    10    10    2169.
#>  7    16    10    10    2169.
#>  8    17    10    10    2169.
#>  9    18    10    10    2169.
#> 10    10    10    11    2169.
#> # … with 753,561 more rows

Created on 2020-07-02 by the [reprex package](https://reprex.tidyverse.org) (v0.3.0)

Ceci dit, pour aller plus loin dans ces optimisations, vous pouvez aussi regarder les possibilités offertes par les algorithmes d'optimisation.
- La fonction 'optim()' dans r-base par exemple
- Sinon, pour aller un peu plus loin, vous pouvez regarder {optimx} : https://cran.r-project.org/web/packa...imx/index.html

Sébastien

[ESYCOME]

Merci pour ton retour Sebastian

J'ai trop simplifié mon code et je me retrouve avec un autre problème.
Mon A,B,C est un vecteur c(A,B,C) et avec ton code je me retrouve tout le temps avec la même valeur en sortie.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
library(dplyr)
library(tidyr)
 
calcul<-function(A,B,C,ad){
Q=c(A,B,C)
#calcul des 4 petites fonctions
sub=Q[1]*12+2
dej=Q[2]*111-33
arg=Q[3]-12
 
if(ad=="q"){
    b=33
  } else if (ad=="s"){
    b=22
  }else if(ad=="d"){
    b=14
  }
zer=b*33+1
 
#total des 4 petites fonctions
 
total=sub+dej+arg+zer
 
return(total)
}
 
 
#exemple de calcul
calcul(10,20,30,"q")
#> [1] 3298.2
 
# Creer toutes les combinaisons
tte_combinaisons <- expand.grid(
  A = 10:100,
  B = 10:100,
  C = 10:100,
  ad= c("q","s","d")
)
# Appliquer la fonction à toutes les combinaisons
# Re-ordonner de la plus petite à la plus grande
tte_combinaisons %>% 
  mutate(resultat = calcul(A,B,C,ad)) %>% 
  arrange(resultat)

J'ai fait pas mal de test ce matin, mais je reste bloqué. Tu as peut être la réponse.

Merci

[statnmap]

Bonjour,

C'est probablement parce que ta fonction n'est pas vectorisée. Elle ne peut pas faire le calcul pour plusieurs lignes en même temps.
Une solution pour contrer cela et le "rowwise()" pour être sûr que les opérations se font ligne par ligne, de manière indépendante.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
tte_combinaisons %>%
rowwise() %>%
mutate(resultat = calcul(A,B,C,ad)) %>%
arrange(resultat)

[ESYCOME]

Bonjour,

Malheureusement, cette solution demande trop de temps de calcul.

Je peux rajouter une contrainte à mon calcul Q[1]<Q[2]<Q[3]

Avec la function optim(), nous ne pouvons pas faire d'intervalle ni d'imposer des nombres entiers.

Une autre solution?

Bon week end

Côme

[statnmap]

Si vous voulez faire de l'optimisation sous contraintes, vous devriez regarder du côté du package {ompr} : https://dirkschumacher.github.io/ompr/

[tototode]

Bonjour,

en continuant sur ton idée d'origine, si le temps de calcul est le problème, tu peux d'une part vectoriser ta fonction, et d'autre part lancer des calculs en parallèle.
Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
calcul2 <- function(A, B, C, ad) {
  sub=A*0.12+2
  dej=B*111-33
  arg=C-12
 
  b <- rep(33, length(A))
  b[ad%in%"s"] <- 22
  b[ad%in%"d"] <- 14
 
  zer = b*33+1
 
  total <- sub + dej + arg + zer
  total
}
 
res2 <- calcul2(tte_combinaisons$A, tte_combinaisons$B, 
                tte_combinaisons$C, ad = "q")

C'est quasiment instantané pour faire le calcul sur toutes les combinaisons en même temps alors que ça prend des plombes si on fait ton calcul ligne à ligne.

Cordialement

[ESYCOME]

Merci Tototode,

ça semble calculer beaucoup plus vite.

Néanmoins je sais récupérer le min de res2 avec la fonction min(res2) mais je souhaite également récupérer les A, B,C et ad correspondant, comment puis-je faire?

J'aimerai que ma fonction me sorte :

le minimum de res2 est "XXXX" avec les valeurs de A="XX", B="YY", C="ZZ", ad="s".

Merci à vous