[maths] Comment représenter cette chose ?

Un sorte de graphe, mais avec des fonctions entre les deux

Le problème exposé dans ce sujet a été résolu.

Bonjour à tous,

tout d’abord, je poste ici, sans conviction quand au choix de la catégorie, peut-être que ce serait mieux dans Sciences, je ne sais pas.

J’aimerais savoir quelle était la façon la plus simple, d’après vous, de représenter par informatique (j’entends en programmation, évidemment), un système de type "Simulink", pour ceux qui ne connaissent pas, ça ressemble à ceci :

Simulink

En gros, chaque "bloc" est une fonction et elles sont reliés ensembles par des fils unidirectionnels (ou pas, mais généralement oui), et il peut y avoir "asservissement" (sorties reliées aux entrées).

Actuellement, j’utilise un système à deux entités, "Block"(bloc) et "Wire" (fil), qui va comme suit :

  • le / les premiers blocs s’exécutent ;
  • ils transmettent au fil.s suivant.s qui prends.ennent la valeur de sortie ;
  • le.s fil.s transmets.tent au bloc.s au(x)quel.s il.s sont relié.s ;
  • ces blocs s’exécutent, puis transmettent, etc.

C’est un système possible à petite échelle, mais tout à fait invraisemblable, car il est extrêmement complexe à créer et à gérer.

Auriez-vous de meilleures idées, sachant que je n’ai pas d’outil aussi puissant que MATLAB à disposition, donc ça reste un projet amateur (en fait, j’ai MATLAB, mais le but est d’intégrer ça sur une page web, donc en JS).

Je ouvert à toute proposition mathématique (je pensait aux graphes, mais comment y mettre des fonctions), informatique ou autre.

Merci bien.

+0 -0

Tu peux t’en sortir avec des graphes comme tu as décrit. Tu n’auras pas plus simple si tu veux rester général.

Si tu veux que le code soit simple, il va falloir faire autrement, en implémentant un code de simulation numérique pour ton système par exemple . Mais tu perds en abstraction.

+0 -0

Puisque tu parles d’asservissement j’imagine que tes blocs représentent des transformées de Laplace. Dans ce cas, tu peux les traduire en équations différentielles et exprimer $\frac{d x_1}{dt}$ et $\frac{d x_2}{dt}$ en fonction de $x_1(t)$ et $x_2(t)$.

Ensuite, comme l’a dit Aabu, il te faudra écrire une simulation numérique pour calculer $x_1$ et $x_2$ au cours du temps, en tenant compte des conditions initiales.

+0 -0

Humm, quel est le problème avec un graphe de fonctions ?

ache

Comment fait-on ? Ma connaissance des graphes est très limitée.

Puisque tu parles d’asservissement j’imagine que tes blocs représentent des transformées de Laplace. Dans ce cas, tu peux les traduire en équations différentielles et exprimer $\frac{d x_1}{dt}$ et $\frac{d x_2}{dt}$ en fonction de $x_1(t)$ et $x_2(t)$.

Askannz

Non, le mot "asservissement" est un abus de langage ici, je ne sais pas comment dire autrement "les sorties sont reliés aux entrées", et comme c’est le terme standard dans les système automatisés, j’ai utilisé ce mot, il faut n’y voir aucun sens mathématique.

+0 -0

Pour mieux répondre à ta question, il faut que tu nous dises ce que tu veux vraiment faire.

C’est un exercice ? Tu veux simuler une système particulier ? Tu veux simuler tout plein de systèmes sous forme de schémas-blocs (type Simulink donc) ? Tu veux simuler des systèmes autres que sous forme de schémas-blocs (circuits électriques par exemple) ? Tu cherches prioritairement à simuler ou à programmer ? Quel est ton objectif ?

+0 -0

@Aabu : l’objectif est de simuler plusieurs systèmes, mais assez simples, rien de fou ; l’objectif est d’intégrer quelques bouts de Simulink à un diaporama JS. J’ai un système fonctionnel mais ça m’a l’air très peu optimisé, donc je me demande s’il est possible de faire mieux. Notons que ce n’est pas la première fois que j’ai besoin de quelque chose de ce type, et je me suis toujours demandé comment faire, donc parlons un peu du cas général avant de rentrer dans les détails si possible.

+0 -0

Un système d’évènement ne pourrait pas fonctionner ? À chaque ajout d’une fonction pure, tu passes aussi l’évènement déclancheur ainsi que l’évènement déclanché (ou des listes d’évènements, peu importe). Vite fait, un truc pondu en Python :

 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
from collections import namedtuple

FunctionDefinition = namedtuple('FunctionDefinition', ['func', 'triggered_by', 'triggers'])

class Dispatcher:
    def __init__(self):
        self.func_defs = []

    def add(self, func, triggered_by, triggers=None):
        self.func_defs.append(FunctionDefinition(func, triggered_by, triggers))

    def trigger(self, event, arg):
        # on cherche les fonctions que l'ont doit lancer sur l'event
        for func_def in self.func_defs:
            if event == func_def.triggered_by:
                self._trigger(func_def, arg)

    def _trigger(self, func_def, arg):
        # on exécute la fonction
        res = func_def.func(arg)

        # si la fonction ne doit rien lancer par la suite, on a fini
        if func_def.triggers is None:
            return

        self.trigger(func_def.triggers, res)

if __name__ == '__main__':
    dispatcher = Dispatcher()

    dispatcher.add(lambda x: 2*x, '1', '2')
    dispatcher.add(lambda x: x+1, '2', '3')
    dispatcher.add(lambda x: x+2, '2', '3')
    dispatcher.add(lambda x: print(x), '3')

    dispatcher.trigger('1', 1)

    # sorti :
    # 3
    # 4
+0 -0

Hier soir j’étais extrèmement fatigué , j’ai pas pu taper ce que je devais.

Du coup, voila un exemple :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
const table = {
  f1: { 
    'function': x => x/4,
    nbParam:1,
    next: ['f2','f3'],
    params: [11],
  },
  f2: {
    function: x=> x+0.25,
    nbParam: 1,
    next: ['f3'],
     params: [],
   },
   { 'name': 'f3',
     'function': (x,y) => x+y,
     nbParam: 2,
     next: [],
     params: [],
   }
};

Du coup, normalement avec ça tu as un graphe (un arbre là m’enfin dans l’idée f3 pourait renvoyé sur f1). Avec un pile pour savoir qui executer quand tu pourrais lancé tout le truc.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
let stack = [['f1', 11]];

function eval( stack ) {
  while( ! stack.empty() ) {
    const currentFunc = table[stack[0].name];
    stack = stack.slice(1); // On retire le premier élement
    const res = currentFunc.function( ...currentFunc.param );

    for( const next in current.nexts ) {
      table[next].params = table[next].params.append(res);
    }

    for( const next in current.nexts ) {
       if( table[next].params.length() === table[next].nbParam ) {
          stack = stack.append(next);
       }
    }
  }
}

Voila, c’est juste un exemple qui ne compile certainement pas car je l’ai tapé dans l’éditeur markdown. Je vois dès que j’ai le temps.

+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte