FP pour simulation et modélisation

Je suis sur le point de démarrer un projet de simulation / modélisation. Je sais déjà que la POO est utilisée pour ce genre de projets. Cependant, l'étude de Haskell m'a fait envisager d'utiliser le paradigme FP pour modéliser un système de composants. Permettez-moi d'expliquer:

Disons que j'ai un composant de type A, caractérisé par un ensemble de données (un paramètre comme la température ou la pression, une PDE et certaines conditions aux limites, etc.) et un composant de type B, caractérisé par un ensemble de données différent (différent ou même paramètre, PDE et conditions aux limites différentes). Supposons également que les fonctions / méthodes qui vont être appliquées sur chaque composant soient les mêmes (une méthode Galerkin par exemple). L'état mutable de l'objet serait utilisé pour les paramètres non constants.

Si je devais utiliser une approche POO, je créerais deux objets qui encapsuleraient les données de chaque type, les méthodes pour résoudre le PDE (l'héritage serait utilisé ici pour la réutilisation du code) et la solution au PDE.

D'un autre côté, si je devais utiliser une approche FP, chaque composant serait décomposé en parties de données et les fonctions qui agiraient sur les données afin d'obtenir la solution pour le PDE. Les paramètres non constants seraient passés en fonction d'autre chose (le temps par exemple) ou exprimés par une sorte de mutabilité (émulation de mutabilité, etc.). Cette approche me semble plus simple en supposant que les opérations linéaires sur les données seraient triviales.

Pour conclure, la mise en œuvre de l'approche FP serait-elle réellement plus simple et plus facile à gérer (ajouter un type de composant différent ou une nouvelle méthode pour résoudre le pde) par rapport à la POO?

Je viens d'un milieu C ++ / Fortran, et je ne suis pas un programmeur professionnel, alors corrigez-moi sur tout ce que je me trompe.

Bonne question, j'ai réfléchi dans le même sens. Historiquement, le paradigme OO est né du besoin de simulation informatique - voir l'histoire de Simula - et malgré les premiers langages OO comme Smalltalk créés par des gens qui savaient ce qu'ils faisaient (par exemple Alan Kay), OO est maintenant sans doute surutilisé et apporte beaucoup trop de complexité accidentelle .

Généralement, les programmes de style FP seront plus courts, plus faciles à tester et plus faciles à modifier que les programmes OO. Comme Rob Harrop l'a dit dans son exposé, l'avenir est-il fonctionnel? , vous ne pouvez jamais obtenir plus simple que les fonctions et les données; les deux se composent à l'infini, pour construire toutes les abstractions nécessaires. Donc, une façon de répondre à votre question (ou suis-je simplement en train de la reformuler? :) est de demander, à quoi ressemblent les fonctions de plus haut niveau et les données d'entrée de plus haut niveau -> données de sortie? Ensuite, vous pouvez commencer à décomposer ces fonctions "alpha" et types de données dans la couche d'abstractions suivante, et répéter si nécessaire.

Une autre perspective (pas tout à fait des réponses) sur votre question est de regarder ce fil (avertissement, je l'ai commencé) sur StackOverflow, certaines des réponses sont très intéressantes: /programming/3431654/how-does- programmation-fonctionnelle-appliquer-aux-simulations

Ma propre opinion à ce stade est, à moins que vous ne modélisiez une situation où il y a vraiment des objets discrets qui n'interagissent que de manière définie (par exemple, un modèle de réseau informatique) - et qui correspondent donc directement aux capacités d'un message propre et propre - langage OO passant-paradigme - il est plus simple d'aller FP. Notez que même dans la communauté de programmation de jeux - où les simulations sont très répandues et les exigences de performances sont primordiales - les développeurs expérimentés s'éloignent du paradigme OO et / ou utilisent plus de FP, par exemple, voir cette discussion HN ou les commentaires de John Carmack sur FP

À mon humble avis, pour presque toutes les tâches d'une complexité raisonnable, la question "est un style FP ou OOP est le meilleur choix" ne peut pas recevoir de réponse objective. En règle générale, dans une telle situation, la question n'est pas «soit FP ou OOP», mais comment combiner les meilleures parties des deux paradigmes pour résoudre votre problème.

Le problème que vous avez résolu ci-dessus semble être très mathématique, et je suppose que vous aurez besoin de quelques opérations matricielles. La POO est très bonne pour modéliser des types de données abstraits, et le calcul matriciel peut être facilement implémenté en tant qu '"objets matriciels" avec des opérations sur des matrices. L'implémentation d'une manière où toutes les opérations matricielles font partie d'une classe matricielle vous aide à garder les choses ensemble qui vont ensemble, afin de maintenir une bonne structure globale.

D'un autre côté, les PDE sont des équations sur les fonctions, et la solution peut être à nouveau fonctionnelle. Donc, utiliser une approche fonctionnelle pour ce type de "composants" peut sembler naturel ici. Ces fonctions peuvent avoir des paramètres matriciels, montrant un exemple de la façon de combiner OOP et FP. Un autre exemple serait une implémentation de classe matricielle, qui utilise des outils fonctionnels pour mapper une certaine opération à chaque élément de votre matrice. Donc, ici aussi, ce n'est pas "OOP versus FP" mais "OOP combiné avec FP" qui vous apporte les meilleurs résultats.