bug giac windows

[cdeval]

Je viens de tomber sur un bug de giac compilé sous vcc.
Cela ne me bloque pas pour ma mise à jour car il est anecdotique mais...
Il s'agit de la fonction asin qui fonctionne mal.
voilà ce que j'obtiens dans OOo :

Code : Tout sélectionner

asin(pi)
-> (i)*ln(sqrt(pi*pi-1)+pi)+0/2

asin(1)
-> 0/2

asin(sqrt(2)/2)
-> pi/4

atan(1)
-> pi/4

cos(pi)
-> -1

simplifier(pi+2pi)
-> 3*pi

pi+2pi
-> pi+2*pi

pi
-> pi

j'ai cru d'abord à un bug d'affichage comme j'avais avec infinity.
Mais pas du tout puisque asin(sqrt(2)/2) fonctionne bien dans OOo.
J'ai ressorti mon projet vcc qui me permet de déboguer.
Dans une console, asin(1) part en boucle infinie en revenant tout le temps à la ligne que tu verras sur la copie d'écran.
Ce qui m'étonne c'est que asin(sqrt(2)/2) en mode console part aussi en boucle infinie.
Bizarre car la librairie que j'utilise dans OOo est la même que celle que j'utilise en console.
Je continue les tests...

[parisse]

peux-tu mettre un point d'arret dans la fonction gen asin(const ...) de usual.cc et regarder ce qu'il s'y passe?

[cdeval]

je viens de mettre un point d'arrêt à la deuxième ligne de :

gen asin(const gen & e0,GIAC_CONTEXT){
static gen normal_sin_pi_12=normal(sin_pi_12,contextptr);
static gen normal_cos_pi_12=normal(cos_pi_12,contextptr);
gen e=frac_neg_out(e0,contextptr);

dès la première instruction normal_sin_pi_12, je perds la main.
en rentrant dans la fonction normal() l'instruction suivante qui ne rend pas la main est :

Code : Tout sélectionner

gen normal(const gen & e,GIAC_CONTEXT){
    return normal(e,true,contextptr);
  }

de sym2poly.cc

je trouvais la valeur de e curieuse. Je suis remonté à sin_pi_12 et le débogueur dit "symbole introuvable" (copie écran).

ensuite dans la fonction normal, l'instruction qui ne rend pas la main est à la ligne 1877 : sort0(l) dans :

Code : Tout sélectionner

   try {
      ee=normalize_sqrt(e,contextptr);
      l=alg_lvar(ee);
      sort0(l);
      tmp=e2r(ee,l,contextptr);
    }

je te joins une copie d'écran pour voir le contenu de l
veux-tu que je continue plus loin dans l'appel des fonctions ?

[parisse]

non, essaie plutot de mettre un point d'arret un peu plus loin dans la fonction asin
if (is_one(e)){
if (angle_radian(contextptr))
return cst_pi_over_2;
return 90;
}
là il devrait prendre le test et renvoyer pi/2. Il y a peut-etre un problème dans l'initialisation de cst_pi_over_2; tu peux remplacer par cst_pi/2 pour voir.

[cdeval]

je viens d'essayer mais le programme n'atteint même pas cette ligne puisqu'il ne ressort pas de la première instruction de asin :

Code : Tout sélectionner

static gen normal_sin_pi_12=normal(sin_pi_12,contextptr);

[parisse]

bon, alors enleve le normal pour voir si ça va jusqu'à is_one(e)

[cdeval]

j'avais essayé mais le compilateur m'indiquait une erreur ailleurs dans usual.cc à cause de la variable normal_sin_pi_12 manquante. Je vais essayer d'enlever les références à cette variable et voir ce que je peux faire.

[parisse]

je voulais juste dire enlever l'appel à normal, pas la déclaration
static gen normal_sin_pi_12=sin_pi_12;

[cdeval]

ok, il a fallu que j'enlève normal pour normal_sin_pi_12 et pour normal_cos_pi_12 car il ne rendait pas la main au programme non plus.
Ensuite, c'est bon, je récupère bien pi/2 pour asin(1). Ouf !

Dis moi si cette modification est raisonnable pour la compil vcc ou bien s'il faut mieux en trouver la cause. J'avais trouvé que c'était dans l'instruction sort0(l) de sym2poly que ça bloquait (cf mon précédent post). Je peux approfondir si besoin.

[parisse]

Non, je vais plutot reprendre le code qui initialise. Je pense que c'est le static qui genere une initialisation trop tot avec vcc.

[cdeval]

cela semble logique. De mémoire, le problème du "infinity" provenait aussi d'une initialisation de l'identificateur static qui se faisait avant le string_infinity alors que celui-ci était placé avant dans le code.
Visiblement vcc ne gère pas l'initialisation des static de la même façon que gcc...

[parisse]

peux-tu tester la chose suivante:

Code : Tout sélectionner

  gen asin(const gen & e0,GIAC_CONTEXT){
    static gen * normal_sin_pi_12_ptr=0;
    if (!normal_sin_pi_12_ptr)
      normal_sin_pi_12_ptr=new gen(normal(sin_pi_12,contextptr));
    static gen * normal_cos_pi_12_ptr=0;
    if (!normal_cos_pi_12_ptr)
      normal_cos_pi_12_ptr=new gen(normal(cos_pi_12,contextptr));
    gen e=frac_neg_out(e0,contextptr);
    if (e.type==_DOUBLE_){
      if (e._DOUBLE_val>=-1 && e._DOUBLE_val<=1){
#ifdef _SOFTMATH_H
	double d= std::giac_gnuwince_asin(e._DOUBLE_val);
#else
	double d=std::asin(e._DOUBLE_val);
#endif
	if (angle_radian(contextptr)) 
	  return d;
	else
	  return d*rad2deg_d;
      }
    }
    if (e.type==_REAL)
      return e._REALptr->asin();
    if ( e.type==_DOUBLE_ || (e.type==_CPLX && (e.subtype || e._CPLXptr->type==_REAL)) ){
      if (angle_radian(contextptr)) 
	return no_context_evalf(asinasln(e,contextptr));
      else
	return no_context_evalf(asinasln(e,contextptr))*gen(rad2deg_d);
    }
    if (is_squarematrix(e))
      return analytic_apply(at_asin,*e._VECTptr,contextptr);
    if (e.type==_VECT)
      return apply(e,giac::asin,contextptr);
    if (is_zero(e,contextptr))
      return e;
    if (is_one(e)){
      if (angle_radian(contextptr))
	return cst_pi_over_2;
      return 90;
    }
    if (e==sin_pi_12 || e==*normal_sin_pi_12_ptr){
      if (angle_radian(contextptr))
	return rdiv(cst_pi,12);
      return 15;
    }
    if (e==cos_pi_12 || e==*normal_cos_pi_12_ptr){
      if (angle_radian(contextptr))
	return 5*cst_pi/12;
      return 75;
    }
    if (e==plus_sqrt3_2){
      if (angle_radian(contextptr))
	return rdiv(cst_pi,3);
      return 60;
    }
    if (e==plus_sqrt2_2){
      if (angle_radian(contextptr)) 
	return rdiv(cst_pi,4);
      return 45;
    }
    if (e==plus_one_half){
      if (angle_radian(contextptr)) 
	return rdiv(cst_pi,6);
      return 30;
    }
    if (e==undef)
      return e;
    if ((e.type==_SYMB) && (e._SYMBptr->sommet==at_neg))
      return -asin(e._SYMBptr->feuille,contextptr);
    if ( (e.type==_INT_) && (e.val<0) )
      return -asin(-e,contextptr);
    if (is_equal(e))
      return apply_to_equal(e,asin,contextptr);
    if (lidnt(e).empty() && is_positive(e*e-1,contextptr))
      return asinasln(e,contextptr);
    return symb_asin(e);
  }