[mOved] Un CAS pour Pedrom? - Page 4

Disons que la license de l'ams ne doit pas être une license libre Donc on peut pas repomper les les codes comme ça...
Par contre Pari a été écrit en C, donc ne devrait pas nécessiter de très très gros changements pour passer en TI. Mais comme j'y connais rien en portage et que je suis newbi en C, je laisse la parole aux gens qui s'y connaissent

Non, je parlais pas de repomper les codes, mais de récuperer directement les fonctions présentes dans la partie TI92 pour la partie TI92+... Mais je ne sais pas si c'est possible (certains avaient essayé - Wormhole, il me semble).

Ce n'est pas portable. Ça ne marche que sur une très petite quantité de TI-92. Même la plupart des TI-92+ HW1 n'ont pas de ROM interne.

C'est un peu hors topic, mais tu penses qu'il y aurait quand même un moyen de le faire ?

Un CAS complet en 64 KO??? C'est du n'importe quoi. Si c'est pour faire un CAS 4 opérations, ce n'est pas la peine.

Alg48, l'un des meilleurs Cas pour hp48, tient en 50ko et a des fonctions vraiment *très* avancées.

Mais le 68k n'est pas un Saturn.

Le 68k est plus puissant qu'un saturn

En taille du code aussi? Il paraît que le 68k, de par son grand nombre de registres, donne du code qui prend beaucoup de place.

C'est vrai (mais ça n'a rien à voir avec le nombre de registres, sur un saturn il y en a 18..)
Mais même si le code 68k prenait deux fois plus de place, ce qui n'est quand même pas le cas, il est possible de faire un Cas correct en relativement peu de place.

(évidemment il faut virer les cochonneries genre DMS qui n'ont pas d'autre intérêt que de créer des situations exceptionnelles et longues à traiter)

y'a giacs comme CAS, c'est fait par le créateur du cas HP ...

A ma connaissance il y a 11 registres imporatant sur le Saturn.
Mais le Saturn gère 64bits au lieu de 32, et fonctionne en quartets et pas en octets, et stoke les informations à l'envers ce qui rend peut-etre la lecture des données plus rapide.

Mais on n'est pas là pour parler de ça

Et c''est vrai que Giac est fait par Bernard Parisse

Je vous propose mon format ?

C'est parti

On ne pourrait pas émuler le CAS de hp ?

lol

le CAS HP, d'après ce que j'ai lu, a été fait à partir du noyau de la ROM, alors sachant qu'il y a jusqu'à des milliers de fonctions, c'est pas gagné

heurf, oki je ne savais pas du tout ...

Alors PpHd, c'était pas au point?

Si. Mes les specifs sont un peu grosses. Je les affine.

	Description du format d'une expression.
	Attention à ne pas melanger les expressions et la syntax du langage derivee (ie melange format expr et ti-basic dans AMS).
	
	Structures :	
		typedef union {
			signed char type;		// Utilise le fait que le 68k a un bus adresse de 23 bits.
			unsigned long size;
			} E;
		
		typedef struct SEs {
			struct SEs	*next;
			short ArgCount; // -1 si variable, 0 si fini.
			E	*expr;	
			} SE;
			
		typedef	struct ETab {
			struct ETab	*next;
			unsigned short	num;
			E	*tab[];
		} ETABLE;
		
	Type:	bit 7 set : Expression sous sa forme normale.
	
		00 : Vide (Detruit).
		
		01 : Vrai. (0 arg).
		02 : Faux. (0 arg).
		03 : Entier.
		04 : Entier P dans un corps/anneau fini N: (2 args > 0, P et N. P <N). 
		05 : Rationnel (2 args: P / Q avec Q >0 et P, Q entier).
		06 : Reel.
		07 : Complexe (2 args: A +I* B, A et B de type numeriques).

		08 : Variable (Var Name) 

		16 : List (Liste d'arg variable).
		17 : Matrice (Liste d'arg variable). FIXME: Ou LIST/LIST

		20 : = (2 args)
		21 : != (2 args)
		22 : <= (2 args)
		23 : < (2 args)
		24 : >= (2 args)
		25 : > (2 args)
		
		36 : Addition (List d'arg variable).
		37 : Multiplication par un scalaire (A * x avec A purement numérique, x symbolique  : 2 args).
		38 : Multiplication (List d'arg variable).
		39 : Pow x ^ N avec N entier numérique. 2 args
		
		64 : sin (1 arg).
		65 : cos (1 arg).
		66 : tan (1 arg).
		68 : asin (1 arg).
		69 : acos (1 arg).
		70 : atan (1 arg).
		72 : exp (1 arg).
		73 : ln (1 arg).
		76 : Integrate (arg, variable, xstart, xend). 4 args.
		77 : Integrate (arg, variable, xnul). 3 args.
		78 : Derivee (arg, variable, number) (Si number < 0, c'est une primitive). 3 args.
		
		96 : Fonction externe : (Liste d'arg variable). Le 1er arg est le nom de la variable. 
			
		99 : Fin de la liste d'arguments variables. END (0 arg).
		
		Les listes d'argument variable sont comme suits :
			Type = Add
				+ 1er arg
				+ 2nd ...
				+ ...
				+ END arg
	Variables:
		E	*EStack;
			Pile courante.
			Fonctionne comme une pile normale.
			*EStack est la premiere expression pushe sur la pile.
		
		SE	*SEList
			List des SE courantes. (Interne)
			
		ETABLE	*ETabList
			Liste des tableaux d'expression courants.(Interne)
			
	Convention des prefixes des noms (FIXME: Trouver des meilleurs noms).
		E: Fonction de base.
		Ex: Fonction de base dont le resultat est mis sur la pile (donc suceptible de faire un garbesh !)
		Ey: Fonction de base dont le resultat est mis sur la pile et dont un argument est lu sur la pile (et detruit).
		
	Fonctions (Kernel niveau 0) :
		type	EType(e)
			Retourne le type d'une expression. (Macro)
		
		void	ExAlloc(long x)
			Alloue x octets sur la pile.
			Attention ! Suceptible de déclencher un Garbesh Collect, si la pile est detectée comme pleine.
			Déclenche une erreur d'allocation si meme apres GC on ne peut satisfaire la demande.
		
		void	ExGC()
			Effectue un garbesh collect de la pile : supprime effectivement toutes les expressions effacées en bouchant les trous. Corrige l'ensemble des pointeurs d'expressions a l'aide des listes maintenues (FIXME: LIST ou TAB ?).
			
		...	Fonctions de calcul numériques sur les entiers / réels : cf GMP.
		
	Fonctions (Kernel niveau 1):
		void	ExNew(TYPE type);
			Depose un header recursif sur la pile qui va englober tous les sous-arguments.
			La taille est calcule automatiquement.
			
		void	EFree(E *e)
			Libere l'expression e de la pile.
			#define EFree(e) (e->type = 0)
		
		bool	EGetFirstSubArg(E *in, SE *out);
			Determine selon le tag combien il y a d'arguments, rempli les champs concequents.
			Ajoute la structure SE a la liste des SE en cours.
			Renvoie vrai s'il y a une sous-expression.
			out->expr = sous-expresion.
		
		void	EFreeSE(SE *se)
			Enleve la SE de la liste des SE courantes.
			
		bool	ENextSubArg(SE *se)
			Passe a l'argument suivant. Enleve automatiquement la SE de la liste s'il n'y a plus d'arguments (Pas besoin d'appeller ENextSubArg). Renvoie vrai s'il y a une sous-expression.
		
		void	ExPush(E *e)
			Depose l'expression sur la pile.
		
		HANDLE	ExPop()
			Recupere la premiere expression de la pile et la copie dans un handle.
			Cette expression est redeposable par un ExPush(HeapDeref(h));
			
		HANDLE	ECopy(E *e)
			Copie l'expression dans un handle.
			Cette expression est redeposable par un ExPush(HeapDeref(h));
		
		int	ECmp(E *e1, E *e2)
			Determine si e1 est plus petit, plus grand, ou egal à e2.
			Le critère de comparaison permet le classement dans un tableau.
			Il aura tendance à regrouper les expressions semblables ensembles (entier avec entier, variable x avec variable x, etc).
			
		ETABLE	*EGetSubArgTable(E *e)
			Calcule l'ensemble des pointeurs de sous-expression d'une expression.
			Le tableau est alloue sur la pile (par alloca) : c'est une macro.
			Ajoute ce table a l'ensemble des tableaux courants.
			
		void	EFreeSubArgTable(ETABLE *t)
			Enleve le tableau de la liste des tableaux courants.
			
		void	ESortSubArgTable(ETABLE *t, int (*)(E*,E*) sortFunc)
			Classe le tableau (Ex: ESortTable(tab, ECmp).
			
		void	ExDoSubArgTable(ETABLE *t, E* (*)(E*) func)
			Appelle la fonction 'func' sur chaque sous argument du tableau.
			Efface l'argument d'entrée si le pointeur de l'entrée et de la sortie sont differents.
			Exemple:	ExDoSubArgTable(tab, ExEval);
			
		void	EMergeSubArgTable(ETABLE *t, E *e)
			Ajoute les sous-arguments de e dans t. Ils sont ajoutés a la fin du tableau (Gestion realloc sur pile...)
			FIXME: Sous-arguments ou e lui meme ? Quel est le mieux ?
			
		E	*EyAdd(E *e)
			Ajoute l'expression e à l'expression courante sur la pile.
			L'argument sur la pile est détruit.
			Les expressions doivent etre sour forme normale.
			Retourne le nouveau sommet de la pile.

		E	*EySub(E *e)
			Enleve l'expression e à l'expression courante sur la pile.
			L'argument sur la pile est détruit.
			Les expressions doivent etre sour forme normale.
			Retourne le nouveau sommet de la pile.

		E	*EyMul(E *e)
			Multipie l'expression e et l'expression courante sur la pile.
			L'argument sur la pile est détruit.
			Les expressions doivent etre sour forme normale.
			Retourne le nouveau sommet de la pile.
			
		E	*EyDiv(E *e)
			Divise par l'expression e l'expression courante sur la pile.
			L'argument sur la pile est détruit.
			Les expressions doivent etre sour forme normale.
			Retourne le nouveau sommet de la pile.
				
		E	*EyPow(E *e)
			Calcule l'expression sur la pile puissance 'e'.
			L'argument sur la pile est détruit.
			Les expressions doivent etre sour forme normale.
			Retourne le nouveau sommet de la pile.
			
		E	*ExEval(E *)
			Evalue et met sous forme normale l'expression e.
			La depose sur le sommet de la pile.
			Retourne le somme de la pile.

Ensuite bien plus tard:

			
	Fonctions (Kernel niveau 2):
		E	*ExPushText(const char *str)
			Convertie la chaine de caractère en expression et la dépose sur la pile.
		
		HANDLE	EGetText(E *e)
			Convertie une expression en chaine de caractère.
			
		HANDLE	EPrepareDisplay(E *e)
			Prepare l'affichage d'une image : détermine les zones (rectangle) que prennent les différentes sous-expressions
			et leur position relative par rapport aux centre.
			
		short	EDisplay(HANDLE h, short x, short y, SCR_RECT *clip)
			Affiche l'expression correspondant au descriptif h (Cf EPrepareDisplay) aux coordonnées (x,y) en clippant si nécessaire.
			La valeur de retour détermine si l'expression déborde en haut (bit 0), en bas (bit 1), a gauche (bit 2) ou a droite (bit 3).
			
		ETABLE	*EGetVariables(E *e)
			Détermine l'ensemble des variables de l'expression.
			
		ETABLE	*EGetPolynom(E *e, E *var)
			Détermine les coefficients du polynome égal à e ayant pour variable var.
			Retourne NULL si l'expression n'est pas représentable sous forme d'un polynome de cette variable.
			
		bool	EIsEqual(E *e1, E* e2)
			Détermine si ces deux expressions sont identiques.
			Note: Faux ne signifie pas forcément qu'elles sont différentes (...)
			
		bool	EIsZero(E *e1)
			Détermine si l'expression est égal à zéro.
			
		bool	EIsNum(E *e)
			Determine si cette expression est purement numérique.
		
		bool	EIsAntiSymetric(E *e, E *var)
			Determine si cette expression est anti-symétrique par rapport à la variable donnée.
			
		bool	EIsSymetric(E *e, E *var)
			Determine si cette expression est symétrique par rapport à la variable donnée.

		bool	EIsFreeOfType(E *e, TYPE t)
			Détermine si l'expression ne contient pas le type t.
			
		bool	EIsIndependant(E *e, E* var)
			Détermine si la variable var n'influence pas l'expression e.
		
		bool	EIsPositive(E *e)
			Détermine si l'expression est positive.
			
		bool	EIsNegative(E *e)
			Détermine si l'expression est positive.
		
		short	EIsSquarematrix(E *e)
			Détermine si c'est une matrice carré er retourne sa taille.
			0 si ce n'est pas une matrice carré.
		
		
		...	Les fonctions EXP / LN / INTEG / DERIV / COS / SIN / TAN / ...
		
	Fonctions (Kernel niveau 3):
		
		E	*ExExpand(E *e)
		E	*ExFactor(E *e)
		...
					
	Exemples:
		Mettre l'addition sous sa forme normale.
		switch (EType(e))
			case E_ADD:
				ESortSubArgTable( tab = EGetSubArgTable(e));
				ExDoSubArgTable(tab, ExEval);
				ExPush(tab->tab[0]);
				for(i = 1 ; i < tab->num ; i++)
					ExAdd(tab->tab[i]);
				break;
		Difficile de faire a la fois plus simple et plus efficace, non ?
		C'est pas parfait : on ne gere pas le cas ou il y a des '+' dans les SE.
		Mais ce n'est pas tres complique de le gerer avec EMergeSubArgTable.
	
	Forme interne (FIXME: a finir)
		a + ( b + c)		-> END A B C +
		a - ( b / c)		-> END END c -1 ^ b * -1 . a +
		2 * x			-> X 2 .
		(2 * x) * y		-> END x y * 2 .
		(x+y)/(x-y)		-> END END x y -1 . + -1 ^ END x y + *
		2^x			-> X 2 LN . EXP
		3*ln(2)*x		-> X 2 LN 3 . .
		6/4 			-> 2 3 RAT
		6*x/-4			-> X 2 -3 RAT .
		x^3+4x^2+3x		-> END X 3 ^ X 2 ^ 4 . X 3 . +
		sqrt(x)			-> X LN 2 1 RAT . EXP
		Integ(tan(x), x)	-> -1 X X TAN DERIV
		x^(n+4)-x		-> END END X LN END N 4 + * EXP X -1 . +
		-6sqrt(2)-11		-> END 2 LN 2 1 RAT . EXP -6 . -11 +
		
		
	Table des variables: (FIXME: a finir)
		Chaque variable possede certaines caracteristiques :
			+ Un ensemble de propriétés (positif, entier, sin(x) = ..., ...)
			+ Une liste de definition (Valeur de variable, definition de fonctions). 
			(Une liste car il peut y avoir plusieurs definitions selon le champ 'MasterOp'). 
			Par exemple, la fonction cos ne fera pas la meme chose selon que l'on est en mode expand ou eval.
			
	

C'est totalement différent du format d'AMS et je ne vois vraiment pas l'intérêt de se compliquer la vie quand on a une description de format existante et plus complète que ce que tu nous ponds là. Il est tout aussi simple d'implémenter un subset du format AMS qui fait exactement la même chose que ton format proposé. Ton format ne simplifie rien du tout, il est juste incompatible gratuitement.

Bon, voilà un mappage de cette proposition de format avec le format AMS, pour montrer à quel point la seule différence est que c'est incompatible:

00 : Vide (Detruit). <-> NOTHING_TAG

01 : Vrai. (0 arg). <-> TRUE_TAG
02 : Faux. (0 arg). <-> FALSE_TAG
04 : Entier positif (...) <-> POSINT_TAG
05 : Entier negatif (...) <-> NEGINT_TAG
06 : Reel (Variable ?) <-> FLOAT_TAG

08 : Variable (Var Name) <-> VAR_NAME_TAG
09 : Var X <-> VAR_X_TAG
10 : Var Y <-> VAR_Y_TAG
12 : Rationnel <-> POSFRAC_TAG, NEGFRAC_TAG
13 : Complexe <-> COMPLEX_TAG
14 : List (Liste d'arg variable). <-> LIST_TAG
15 : Matrice (Liste d'arg variable). FIXME: Ou LIST/LIST <-> liste de listes comme proposé en "FIXME"

20 : = (2 args) <-> EQ_TAG
21 : != (2 args) <-> NE_TAG
22 : <= (2 args) <-> LE_TAG
23 : < (2 args) <-> LT_TAG
24 : >= (2 args) <-> GE_TAG
25 : > (2 args) (PpHd, j'ai corrigé une erreur là) <-> GT_TAG
26 : appartient (2 args dont le second est une liste ou une matrice ou une expression compose de AND/OR/>/etc) FIXME: Utile ? -> réponse: non.
27 : AND (2 args) <-> AND_TAG
28 : OR (2 args) <-> OR_TAG
29 : XOR (2 args) <-> XOR_TAG
30 : NOT (1 arg) <-> NOT_TAG

36 : Addition (List d'arg variable). <-> ADD_TAG. Et pourquoi une liste d'arguments variable? L'addition est un opérateur binaire à la base.
37 : Scal (A * x avec A purement numérique, x symbolique : 2 args). <-> MUL_TAG (pas besoin de tag particulier, et puis c'est illogique: 5*3 -> tag 38, 5*x -> tag 37, y*x -> tag 38 ???)
38 : Multiplication (List d'arg variable). <-> MUL_TAG, et même remarque que pour l'addition.
39 : Pow x ^ N avec N entier numérique (FIXME: entier ou rationnel ?). 2 args <-> POW_TAG
40 : modulo x % N (2 args) <-> MOD_TAG. Et un parseur compatible AMS ne devra pas traîter % comme mod parce que le % signifie autre chose (division par 100).

64 : sin (1 arg). <-> SIN_TAG
65 : cos (1 arg). <-> COS_TAG
66 : tan (1 arg). <-> TAN_TAG
68 : asin (1 arg). <-> ASIN_TAG
69 : acos (1 arg). <-> ACOS_TAG
70 : atan (1 arg). <-> ATAN_TAG
72 : exp (1 arg). <-> EXPF_TAG
73 : ln (1 arg). <-> LN_TAG
76 : Integrate (arg, variable, xstart, xend). 4 args. <-> INTEGRATE_TAG
77 : Integrate (arg, variable, xnul). 3 args. <-> INTEGRATE_TAG (pas besoin de tag différent, il suffit de vérifier le nombre d'arguments présent avant END_TAG)
Et tu as oublié Integrate (arg, variable).
78 : Derivee (arg, variable, number) (Si number < 0, c'est une primitive). 3 args. <-> DIFFERENTIATE_TAG
Et tu as oublié Derivee (arg, variable).

96 : Fonction externe : (Liste d'arg variable). 1er arg est un nom de variable. (FIXME: Est-ce une bonne idee ?) <-> USERFUNC_TAG
IDEE: Fonction reciproque ont le nom qui se termine par '-1' ? -> mauvaise idée. Je ne connais aucun CAS qui utilise ça.
Attention: si tous les arguments d'entrees sont constants, on suppose que la fonction renvoit une valeur numérique. (FIXME bien ?) -> non.


99 : Fin de la liste d'arguments variables. END (0 arg). <-> END_TAG

Bref, à part des détails, pour lesquels je juge le choix de PpHd moins judicieux que celui de AMS, les 2 formats reviennent exactement au même en termes d'expressivité, donc je ne vois pas du tout l'intérêt de se compliquer la vie à spécifier un format incompatible quand on peut avoir la compatibilité tout aussi simplement et sans se fatiguer à développer une spécification de format.

par contre, intégrer les TSR à PedroM, ce serait possible ???
en gros, créer un format spécifique aux TSR qui permettrait d'être automatiquement lancer aprés un reset ou un truc du genre...

Et pour les variables et fonctions:

Variables:
EStack <-> top_estack
*SEList: interne, donc à priori tu en fais ce que tu veux
*ETabList: idem
MasterOp: idem

Fonctions (Kernel niveau 0) :
EType(e) <-> GetArgType
ExAlloc(long x) -> Si on alloue, ce n'est plus une pile! Et je trouve le système de AMS (une vraie pile, mais possibilité de nettoyer avec delete_between) plus pratique.
ExGC() -> idem!

Fonctions (Kernel niveau 1):
ExNew: inutile avec la méthode de AMS: on pushe directement les expressions et le END_TAG qu'il faut
EFree <-> (vaguement) delete_between. Et même remarque que pour ExAlloc.
EGetSubArg <-> remaining_element_count
(Je saut les fonctions sur les SE parce que c'est de l'interne.)
ExPush <-> push_expression
ExPop <-> pas d'équivalence exacte, mais facilement implémentable en termes de bottom_estack, de next_expression_index et de HS_popEStack. Et rien ne t'empêche de le proposer directement en interne.
ECopy <-> pas d'équivalence exacte, mais facilement implémentable en termes de next_expression_index, de HeapAlloc et de memcpy. Et rien ne t'empêche de le proposer directement en interne.
ECmp <-> compare_expressions
(Je saute les fonctions sur les "argument lists". C'est nettement plus simple avec le format d'AMS: il suffit d'utiliser next_expression_index ou EX_getArg.)
*ExyAdd <-> push_sum
*ExySub <-> push_difference
*ExyMul <-> push_product
*ExyDiv <-> push_reciprocal suivi de push_product
*ExyPow <-> push_pow
*ExEval <-> push_simplify ou push_internal_simplify

Fonctions (Kernel niveau 2):
ExPushText <-> push_parse_text
EGetText <-> Parse1DExpr
EPrepareDisplay <-> Parse2DExpr
EDisplay <-> Print2DExpr
EGetVariables: je ne vois pas d'équivalent en un seul appel, mais rien ne t'empêche de l'implémenter en interne
EGetPolynom: idem
EIsEqual <-> push_difference suivi de is_complex0
EIsZero <-> is_complex0
EIsNum <-> is_constant
EIsAntiSymetric <-> is_antisymmetric
EIsSymetric <-> is_symmetric
EIsFreeOfType <-> is_free_of_tag (le tag identifiant le type)
EIsIndependant <-> is_independent_of
EIsPositive <-> is_positive ou is_nonnegative (attention à la différence subtile entre "positif" en français et "positive" en anglais)
EIsNegative <-> is_negative ou is_nonpositive (même remarque)
EIsSquarematrix <-> is_square_matrix

Fonctions (Kernel niveau 3):
ExExpand <-> push_expand
ExFactor <-> push_factor

PpHd a écrit :
Exemples:
Mettre l'addition sous sa forme normale.
switch (EType(e))
case E_ADD:
ESortSubArgTable( tab = EGetSubArgTable(e));
ExDoSubArgTable(tab, ExEval);
ExPush(tab->tab[0]);
for(i = 1 ; i < tab->num ; i++)
ExAdd(tab->tab[i]);
break;
Difficile de faire a la fois plus simple et plus efficace, non ? C'est pas parfait : on ne gere pas le cas ou il y a des '+' dans les SE.

Donne-nous un exemple complet et on en reparlera.

Tu oublies le champ 'size'.

>00 : Vide (Detruit). <-> NOTHING_TAG
>01 : Vrai. (0 arg). <-> TRUE_TAG
>02 : Faux. (0 arg). <-> FALSE_TAG
>04 : Entier positif (...) <-> POSINT_TAG
>05 : Entier negatif (...) <-> NEGINT_TAG
>06 : Reel (Variable ?) <-> FLOAT_TAG
>08 : Variable (Var Name) <-> VAR_NAME_TAG
>09 : Var X <-> VAR_X_TAG
>10 : Var Y <-> VAR_Y_TAG
>12 : Rationnel <-> POSFRAC_TAG, NEGFRAC_TAG
>13 : Complexe <-> COMPLEX_TAG
>14 : List (Liste d'arg variable). <-> LIST_TAG
>15 : Matrice (Liste d'arg variable). FIXME: Ou LIST/LIST <-> liste de listes comme proposé en "FIXME"
>20 : = (2 args) <-> EQ_TAG
>21 : != (2 args) <-> NE_TAG
>22 : <= (2 args) <-> LE_TAG
>23 : < (2 args) <-> LT_TAG
>24 : >= (2 args) <-> GE_TAG
>25 : > (2 args) (PpHd, j'ai corrigé une erreur là) <-> GT_TAG
>26 : appartient (2 args dont le second est une liste ou une matrice ou une expression compose de AND/OR/>/etc) FIXME: Utile ? -> réponse: non.
>27 : AND (2 args) <-> AND_TAG
>28 : OR (2 args) <-> OR_TAG
>29 : XOR (2 args) <-> XOR_TAG
>30 : NOT (1 arg) <-> NOT_TAG
Je ne vais pas changer cela pour faire joli. C'est correct.

>36 : Addition (List d'arg variable). <-> ADD_TAG. Et pourquoi une liste d'arguments variable? L'addition est un opérateur binaire à la base.
>38 : Multiplication (List d'arg variable). <-> MUL_TAG, et même remarque que pour l'addition.

1. Parce que c'est un opérateur commutatif.
2. Mapple fait aussi du variable.
3. C'est plus rapide, et plus efficace.

>37 : Scal (A * x avec A purement numérique, x symbolique : 2 args). <-> MUL_TAG (pas besoin de tag particulier, et puis c'est illogique: 5*3 -> tag 38, 5*x -> tag 37, y*x -> tag 38 ???)
Si !
* multiplier et . (scalaire) sont sensiblement différents.
Cela permet de gérer simplement et efficacement 2x-x=x.

>40 : modulo x % N (2 args) <-> MOD_TAG. Et un parseur compatible AMS ne devra pas traîter % comme mod parce que le % signifie autre chose (division par 100).
Ce n'est pas un gros problème.

>76 : Integrate (arg, variable, xstart, xend). 4 args. <-> INTEGRATE_TAG
>77 : Integrate (arg, variable, xnul). 3 args. <-> INTEGRATE_TAG (pas besoin de tag différent, il suffit de vérifier le nombre d'arguments présent avant END_TAG)
C'est + rapide et simple de ne pas vérifier. Mais ca peut se discuter.

>Et tu as oublié Integrate (arg, variable).
Non
Regarde dérivée un peu mieux.

>78 : Derivee (arg, variable, number) (Si number < 0, c'est une primitive). 3 args. <-> DIFFERENTIATE_TAG
Et tu as oublié Derivee (arg, variable).
Non. Derivee(arg, variable, 1)

>96 : Fonction externe : (Liste d'arg variable). 1er arg est un nom de variable. (FIXME: Est-ce une bonne idee ?) <-> USERFUNC_TAG
IDEE: Fonction reciproque ont le nom qui se termine par '-1' ? -> mauvaise idée. Je ne connais aucun CAS qui utilise ça.
Pourquoi pas ? Des explications ?

>Attention: si tous les arguments d'entrees sont constants, on suppose que la fonction renvoit une valeur numérique. (FIXME bien ?) -> non.
Des exemples de fonctions dont toutes les entrees sont numériques et dont la sortie n'est pas numérique ?


>Bref, à part des détails, pour lesquels je juge le choix de PpHd moins judicieux que celui de AMS,
Lesquels ?

>les 2 formats reviennent exactement au même en termes d'expressivité,
Forcément. Un CAS permet a peu près la même chose.

>donc je ne vois pas du tout l'intérêt de se compliquer la vie à spécifier un format incompatible quand on peut avoir la compatibilité tout aussi simplement et sans se fatiguer à développer une spécification de format.
Tu oublies toutes les fonctionnalités internes. Es...

Kevin Kofler a écrit :
ExAlloc(long x) -> Si on alloue, ce n'est plus une pile! Et je trouve le système de AMS (une vraie pile, mais possibilité de nettoyer avec delete_between) plus pratique.
ExGC() -> idem!
(Je saut les fonctions sur les SE parce que c'est de l'interne.)
(Je saute les fonctions sur les "argument lists". C'est nettement plus simple avec le format d'AMS: il suffit d'utiliser next_expression_index ou EX_getArg.)
EGetVariables: je ne vois pas d'équivalent en un seul appel, mais rien ne t'empêche de l'implémenter en interne
EGetPolynom: idem

C'est pourtant la que ce situe la veritable force de ce format. Relis attentivement et demande ce que tu n'as pas compris.

Pourquoi tu fais des tags à l'envers comme TI ???

> Parce que c'est un opérateur commutatif.
associatif tu veux dire

PpHd a écrit :
>36 : Addition (List d'arg variable). <-> ADD_TAG. Et pourquoi une liste d'arguments variable? L'addition est un opérateur binaire à la base.
>38 : Multiplication (List d'arg variable). <-> MUL_TAG, et même remarque que pour l'addition.

1. Parce que c'est un opérateur commutatif.
2. Mapple fait aussi du variable. 3. C'est plus rapide, et plus efficace.

Pas nécessairement. Si TI a codé l'addition en 2 arguments uniquement, il doit bien y avoir une raison.

>37 : Scal (A * x avec A purement numérique, x symbolique : 2 args). <-> MUL_TAG (pas besoin de tag particulier, et puis c'est illogique: 5*3 -> tag 38, 5*x -> tag 37, y*x -> tag 38 ???)
Si ! * multiplier et . (scalaire) sont sensiblement différents.

Pas du tout! Il n'y a aucune différence fondamentale entre 5*3, 5*x et y*x. Et pourquoi utiliser le même code pour 5*3 et pour y*x, mais un code différent pour 5*x?

Cela permet de gérer simplement et efficacement 2x-x=x.

is_constant est là pour ça.

>40 : modulo x % N (2 args) <-> MOD_TAG. Et un parseur compatible AMS ne devra pas traîter % comme mod parce que le % signifie autre chose (division par 100). Ce n'est pas un gros problème.

Si. On est compatibles ou on ne l'est pas.

>76 : Integrate (arg, variable, xstart, xend). 4 args. <-> INTEGRATE_TAG
>77 : Integrate (arg, variable, xnul). 3 args. <-> INTEGRATE_TAG (pas besoin de tag différent, il suffit de vérifier le nombre d'arguments présent avant END_TAG) C'est + rapide et simple de ne pas vérifier. Mais ca peut se discuter.

Mais de toute façon je ne discute pas juste des détails, mais du format en entier. Même si tu rends les détails identiques à AMS, ça reste totalement incompatible avec le format d'AMS.

>Et tu as oublié Integrate (arg, variable).
Non Regarde dérivée un peu mieux.

Désolé, je n'ai vu la table des simplifications qu'après. Mais ça reste bizarre comme codage.

IDEE: Fonction reciproque ont le nom qui se termine par '-1' ? -> mauvaise idée. Je ne connais aucun CAS qui utilise ça. Pourquoi pas ? Des explications ?

Parce que je ne connais aucun CAS qui utilise ça.
Mais pour qu'on se comprenne: tu parles de -1 signifiant automatiquement "réciproque" (donc c'est le CAS qui interprète le -1) ou juste de la possibilité de mettre des noms en -1 (donc c'est l'utilisateur qui interprète le -1)?

>Attention: si tous les arguments d'entrees sont constants, on suppose que la fonction renvoit une valeur numérique. (FIXME bien ?) -> non. Des exemples de fonctions dont toutes les entrees sont numériques et dont la sortie n'est pas numérique ?

Define f(a)=a*x

>Bref, à part des détails, pour lesquels je juge le choix de PpHd moins judicieux que celui de AMS, Lesquels ?

Tout ce que j'ai critiqué.

>donc je ne vois pas du tout l'intérêt de se compliquer la vie à spécifier un format incompatible quand on peut avoir la compatibilité tout aussi simplement et sans se fatiguer à développer une spécification de format. Tu oublies toutes les fonctionnalités internes. Es...

Tu travailles en interne comme tu veux, mais ça ne t'empêche pas d'utiliser la représentation de AMS en externe. Et attention, je compte la représentation "interne" de AMS (cf. push_internal_simplify) comme de l'externe vu que les programmes de calcul formel en C ou en assembleur travaillent dessus.

Et je n'ai toujours pas compris pourquoi après tous ces efforts pour la compatibilité AMS, tu es prêt à ignorer complètement la compatibilité avec AMS sur un domaine important comme le CAS. Et ne prétends pas que ça ne concerne pas les programmes utilisateur. Il y a:
* les programmes TI-BASIC
* les programmes en C ou assembleur utilisant le calcul formel: EQW, Hail, gosper89 etc.
Les 2 ensemble, ça donne des milliers de programmes. Plus Pedrom sera compatible avec AMS pour le CAS, plus il y aura de programmes parmi ces milliers qui marcheront. 0 compatibilité = 0 programmes parmi ces 2 catégories ne marcheront.