#!/bin/csh

#######################################################################################################################################
#                                                                                                                                     #
#         C O N V E R S I O N   D ' U N   R A T I O N N E L   I R R E D U C T I B L E                                                 #
#         E N   U N   P O L Y N O M E   A   C O E F F I C I E N T S   E N T I E R S  :                                                #
#                                                                                                                                     #
#                                                                                                                                     #
#         Utilisation :                                                                                                               #
#                                                                                                                                     #
#                   $xcg/RationnelPolynome.01$vv$Z          <Numerateur> <Denominateur>                                               #
#                                                                                                                                     #
#                                                                                                                                     #
#         Nota :                                                                                                                      #
#                                                                                                                                     #
#                     Voir 'v $xcg/PolynomeRationnel.01$vv$Z'                                                                         #
#                   pour effectuer la conversion inverse...                                                                           #
#                                                                                                                                     #
#                                                                                                                                     #
#         Author of '$xcg/RationnelPolynome.01$vv$Z' :                                                                                #
#                                                                                                                                     #
#                     Jean-Francois Colonna (LACTAMME, 20200530140946).                                                               #
#                                                                                                                                     #
#######################################################################################################################################

set       Numer=$1
set       Denom=$2

set       VNumer=`calculINS $Numer`
set       VDenom=`calculINS $Denom`

set       FauxPremier=1
                                        # On est oblige de tricher a cause de '$FACTO' qui ne factorise pas 1...                      #

if        (    ("$Numer" == "$VNumer")                                                                                                  \
          &&   ($VNumer >= $FauxPremier)                                                                                                \
           ) then
else
          EROR      "Le numerateur (=$Numer) doit etre entier et superieur ou egal a $FauxPremier."
          set       Numer=$FauxPremier
endif

if        (    ("$Denom" == "$VDenom")                                                                                                  \
          &&   ($VDenom >= $FauxPremier)                                                                                                \
           ) then
else
          EROR      "Le denominateur (=$Denom) doit etre entier et superieur ou egal a $FauxPremier."
          set       Denom=$FauxPremier
endif

set       PGCD=`$xcg/PGCD.01$X a=$Numer b=$Denom signe="$K_VIDE"`

if        ($PGCD == 1) then
          set       NoMbReN=`calculINS log($Numer)+2`
          set       NoMbReD=`calculINS log($Denom)+2`
          set       NoMbRe=`$xcg/MUL2.01$X x=$NoMbReN y=$NoMbReD signe="$K_VIDE" entier=VRAI`
                                        # Pour connaitre le nombre de nombres premiers utiles, on prend une grosse marge de           #
                                        # securite, le tout etant inspire de 'v $xil/defi_K2$vv$DEF LOIN'...                          #
                                        #                                                                                             #
                                        # Finalement, en faisant '$xcg/MUL2.01$X' plutot que '$xcg/MAX2.01$X', on prend une           #
                                        # grosse marge de securite...                                                                 #

          set       LNombresPremiers=`$xci/valeurs_Goldbach$X p=1 d=$NoMbRe editer_nombres_premiers=VRAI calculer_decompositions=FAUX`

          if   ($Numer == 1) then
               set  FactN="$FauxPremier^1+"
          else
               set  FactN=`$FACTO $Numer | $SE -e "s/^.*: *//" | $R "$K_BLANC" "$K_NL" | $UNI -c | $AW ' { print $2 "^" $1 "+"} '`
                                        # Factorisation du Numerateur.                                                                #
          endif

          if   ($Denom == 1) then
               set  FactD="$FauxPremier^1-"
          else
               set  FactD=`$FACTO $Denom | $SE -e "s/^.*: *//" | $R "$K_BLANC" "$K_NL" | $UNI -c | $AW ' { print $2 "^" $1 "-"} '`
                                        # Factorisation du Denominateur.                                                              #
          endif

          set       FactND=`echo "$FactN $FactD" | $R "$K_BLANC" "$K_NL" | $SOR -n | $SE -e 's/^\(.*\)\(.\)$/\2\1/'`
                                        # Factorisation de Numerateur/Denominateur avec donc a priori a la fois des exposants         #
                                        # positifs (venant du Numerateur) et negatifs (venant du Denominateur).                       #
          set       Dernier=`echo "$FactND[$#FactND]" | $SE -e "s/^.\([$Alphabet_0_9][$Alphabet_0_9]*\)[^$Alphabet_0_9].*"'$/\1/'`
                                        # Plus grand nombre premier utile.                                                            #

          set       Exposant=0
          set       Indice=1
          set       Polynome="$K_VIDE"

          set       A09="$Alphabet_0_9"

          foreach   NPrem ($LNombresPremiers)
          set       Present=`echo "$FactND" | $R "$K_BLANC" "$K_NL" | $EGRE "^.$NPrem""[^$A09]" | $SE -e "s/^\(.\)$NPrem""[^$A09]/\1/"`

                    if        ("$Present" != "$K_VIDE") then
                              set       Polynome="($Present""*X""^""$Exposant"")""+$Polynome"
                    else
                    endif

                    @         Exposant = $Exposant + 1
          end

          if        ("$Polynome" == "$K_VIDE") then
                    set       Polynome="0"
          else
          endif

          echo      "$Polynome"                                                                                                   |     \
          $SE       -e "s/^+//"                                                                                                         \
                    -e "s/\(+(\)+/\1/g"                                                                                                 \
                    -e "s/+\((\)\(-\)/\2\1/g"                                                                                           \
                    -e"s/^\((\)\(.\)/\2\1/g"                                                                                            \
                    -e "s/\((\)\([$Alphabet_0_9]*\*\)/\2\1/g"                                                                           \
                    -e "s/\([-+]\)1\*/\1/g"                                                                                             \
                    -e 's/+$//'                                                                                                         \
                    -e "s/(X\^0)/1/g"                                                                                                   \
                    -e "s/\([^$Alphabet_0_9][$Alphabet_0_9]*\)\*1"'$/\1/'                                                               \
                    -e "s+^+$Numer/$Denom ==> P(X) = +"
else
          EROR      "Le numerateur (=$Numer) et le denominateur (=$Denom) ne sont pas premiers entre-eux (PGCD=$PGCD)."
endif