PpHd (./1) :
I release today the first alpha public version of MAYLIB:

Excellent

Quelques remarques/questions :

This function, contrary to all other, may not copy the expression while changing its form (for efficiency reasons).

"might not" plutôt ? ("may not" ça veut dire qu'elle a pas le droit de copier l'expression)

The value returned is a pointer to the allocated memory, which is suitably aligned for a long, or NULL if the request fails.

L'alignement d'un "long" peut être plus petit que celui d'une structure, je pense que tu veux plutôt "suitably aligned for a struct" (l'alignement de toutes les structures est le même, donc comme une structure peut contenir un long l'alignement est plus grand).

If the node of x is an user defined type, it returns the type name. In both cases, the only way to identify it is to use strcmp.

Je comprends pas : pourquoi on peut pas comparer bêtement les pointeurs comme avec les fonctions internes ? Tu prends le nom d'un type d'extension dans un champ et pas en appelant une méthode, donc a priori il ne bouge pas ?

The fact of avoiding any name collision (between function and type) is let to the user.

Ca pose un problème d'évolutivité, qu'est-ce qui se passe si je définis une fonction digamma et qu'elle est implémentée dans une version future de maylib ? Ca veut dire qu'il faut que je préfixe toutes mes fonctions pour éviter les collisions ? Ou alors que la liste des fonctions de maylib est figée ?

Wild-cards behave like symbols: they are subject to the same transformations. For example, $0+$0 is transformed to 2*$0.

Est-ce que ça veut dire que par exemple si sin(2*x)+y est réécrit en y+sin(2*x) et que sin(2*a)+sin(sin(b)) est réécrit en sin(sin(b))+sin(2*a), alors sin(2*a)+sin(sin(b)) ne sera pas de la forme sin(2*$1)+$2, ou est-ce que le matching prend en compte la commutativité ?

priority : an integer between 1 and 1000. It defines its priority accross all extension class. The priority defines the order of the calls to the overloaded operators if there is more than one extension class as an argument to the operator: it calls the overloaded function which corresponds to the extension class of upper priority if doing inter-class computing is not needed (for example in A^B) or call the overloaded functions in the same order than their priority otherwise. For example, in the expression 2+A1+B1+A2+B2 if the priority of A is lower than B, the overloaded function of A is called before with 2+A1+A2 as an argument. Its returned value is then given as input to the overload function of B. The case whose two or more extension class have the same priority is undefined. 1 is the lowest priority, and 1000 the highest.

Tu ne spécifies pas la priorité des types de base ?

level is the priority level of the current operator (0 for +, 1 for *, 2 for pow, 3 for func) if the priority of the extension is greater, some brackets might be needed to have a proper convertion (default: 3).

Ce serait pas plus intéressant de mettre genre 100/200/300/400, pour qu'on puisse définir des extensions de priorité intermédiaire ? Et tu n'as pas une priorité encore supérieure pour les opérateurs unaires ?

void convert2str (may_t extension, int level, void (*convert)(may_t ext,int level), void (*put_string)(const char *string));

- Tu ne précises pas si on peut appeler plusieurs fois put_string (j'imagine que oui ?)
- Ce serait pas plus logique d'appeler convert() put_may() ? Et pourquoi "ext" s'appelle comme ça, il peut avoir un type quelconque et pas seulement un type de l'extension ? Ou alors j'ai rien compris ?

int non_commutative_product;

Ca me paraît pas très extensible comme façon de savoir si la classe vérifie un prédicat, ça veut dire que c'est impossible de linker ensemble deux modules qui ont été compilés avec des versions différentes de maylib (alors que si tu veux t'en servir comme CAS sur calculatrice la compatibilité binaire est super importante). Pourquoi pas utiliser à la place un champ avec des flags genre ASSERT_COMMUTATIVE_PRODUCT ? Comme ça tu pourras en rajouter d'autres quand t'en auras besoin...

Hold x: mark it as evaluated without performing any simplification. This function may be dangerous, since the other functions expect an evaluated form.

Dangereux à quel point ? Crash ou résultats faux ?



Est-ce que may_eval(may_foo_c(may_bar_c(x,y),z)) est équivalent à may_foo(may_bar(x,y),z) ? (modulo la rapidité si par exemple foo=mul et z=0)