3 routines : bin_hexa, hexa_bin et y=ax+b

rem ' Convertisseur binaire-hexadécimal
   dim a$ : rem Chaîne de caractère contenant le nombre binaire à convertir
   dim ch$ : rem Chaîne Hexadécimale
   label clic

rem form0
   caption 0,"Convertisseur Binaire-Hexadécimal"
  
edit 10
   set_focus 10

button 20
   left 20,200
   on_click 20,clic

end

clic:
   a$=text$(10)
   converti_bin_hexa(a$)
   caption 0,ch$
return

sub converti_bin_hexa(a$) : rem Convertisseur binaire-héxadécimal
   rem a$ est le nombre binaire converti en chaîne de caractères
   rem ch$ Chaîne Hexadécimale, doit être définie en variable globale
   dim_local i% , d% , h%
   if numeric(a$)=1
      for i%=1 to len(a$)
         if (mid$(a$,i%,1)<>"0") and (mid$(a$,i%,1)<>"1")
            h%=1
         end_if
      next i%
      if h%=0
         for i%=1 to len(a$)
            d%=d%+(val(mid$(a$,i%,1))*power(2,len(a$)-i%))
         next i%
         ch$=hex$(d%)
         if len(ch$)<(int((len(a$)-1)/4)+1)
            ch$=string$((int((len(a$)-1)/4)+1)-len(ch$),"0")+ch$
         end_if
      end_if
   end_if
end_sub

rem ' Convertisseur hexadécimal-binaire
   dim a$ : rem Chaîne de caractère contenant le nombre hexadécimal à convertir
   dim nb$ : rem Nombre Binaire à trouver
   label clic

rem form0
   caption 0,"Convertisseur Hexadécimal-Binaire"
  
edit 10
   set_focus 10

button 20
   left 20,200
   on_click 20,clic

end

clic:
   a$=text$(10)
   converti_hexa_bin(a$)
   caption 0,nb$
return

sub converti_hexa_bin(a$) : rem Convertisseur d`hexadécimal en binaire
   rem a$ est le nombre hexadécimal exprimé en chaîne de caractères
   rem nb$ Nombre Binaire, doit être défini en variable globale
   dim_local d% , c% , i% , h%
   for i%=1 to len(a$)
      c%=asc(mid$(a$,i%,1))
      if (c%<48) or (c%>57 and c%<65) or (c%>70)
         h%=1
      end_if
   next i%
   if h%=0
      d%=hex(a$)
      nb$=""
      while d%>0
         nb$=str$(mod(d%,2))+nb$
         d%=int(d%/2)
      end_while
   end_if
end_sub

rem ' Droite y=ax+b et déplacement d`un objet-système sur une surface
   dim q% , x1% , y1% , x2% , y2% , a , b , i% , z%
   dim a$ , b$ : a$=chr$(13) : rem Pour la réglette
   rem x1%_y1% et x2%_y2% sont les coordonnées des poins de départ et d`arrivée
   rem i% est la variable du for-to-next
   rem a et b sont les coefficients de la formule y=ax+b
   rem z% est le coefficient affecté au step du for-to-next

alpha 4
   left 4,20
   caption 4,"20  40  60  80  100 120 140 160 180 200 220 240 260 280 300"
  
alpha 6
   left 6,2
   b$="10"+a$+"20"+a$+"40"+a$+"50"+a$+"60"+a$+"70"+a$+"90"+a$+"100"+a$
   b$=b$+"110"+a$+"120"+a$+"140"+a$+"150"+a$+"160"+a$+"170"+a$+"180"+a$+"190"+a$+"200"
   caption 6,b$

alpha 10
   left 10,100
   top 10,50
   font_size 10,12
   caption 10,"o"
  
rem Valeurs affectées aux variables
   q%=10 : rem Numéro de l`objet-système ALPHA
   x1%=300 : rem Abscisse d`origine du déplacement
   x2%=100 : rem Abscisse de destination du déplacement
   y1%=100 : rem Ordonnée d`origine du déplacement
   y2%=50 : rem Ordonnée de destination du déplacement
   z%=1 : rem Coefficient du step du for-to-next
   droite(q%,x1%,y1%,x2%,y2%,z%)
   x1%=x2%
   y1%=y2%
   x2%=150
   y2%=200
   droite(q%,x1%,y1%,x2%,y2%,z%)
   x1%=x2%
   y1%=y2%
   x2%=300
   y2%=50
   droite(q%,x1%,y1%,x2%,y2%,z%)
  
end

sub droite(q%,x1%,y1%,x2%,y2%,z%) : rem Affichage du déplacement de l`Obj-Syst
   dim_local i% , a , b
   a=(y2%-y1%)/(x2%-x1%)
   b=y1%-a*x1% : rem calculs selon la formule y=ax+b
   for i%=x1% to x2% step sgn(x2%-x1%)*z%
      left 10,i%
      top 10,a*i%+b
      display
      pause 10
   next i%
end_sub

sub converti_bin_hexa(a$) : rem Convertisseur binaire-héxadécimal
   rem a$ est le nombre binaire converti en chaîne de caractères
   rem ch$ Chaîne Hexadécimale, doit être définie en variable générale
   dim_local i% , d%
   if numeric(a$)=1
      for i%=1 to len(a$)
          if (mid$(a$,i%,1) <> "0") and (mid$(a$,i%,1) <> "1")
             message " Vous vous foutez de ma guelle ou quoi?" + chr$(13) +"Ceci n'est pas un nombre binaire"
             exit_sub
         end_if
         d%=d%+(val(mid$(a$,i%,1))*power(2,len(a$)-i%))
      next i%
      ch$=hex$(d%)
      if len(ch$)<(int((len(a$)-1)/4)+1)
         ch$=string$((int((len(a$)-1)/4)+1)-len(ch$),"0")+ch$
      end_if
   end_if
end_sub

rem ============================================================================
rem       Opérations arithmétiques en base quelconque (entre 2 et 36)
rem ============================================================================
rem Les lettres A, B, C, ..., Z représentent les valeurs 10, 11, 12, ..., 36
rem dans les bases > 10
rem Les nombres sont d abord convertis de la base b à la base 10 par la procédure
rem DecodeBase, puis l opération est faite en base 10 et le résultat est converti
rem de la base 10 à la base b par la procédure CodeBase.
rem ============================================================================

Montre_Moi_Ce_Dont_Tu_Es_capable()

end
rem ============================================================================
SUB Montre_Moi_Ce_Dont_Tu_Es_capable()
    label opt,calcul,fin
    dim XMaxReal : XMaxReal = power(10,30)
    dim ib : ' base de départ
    dim x$ : ' chaine contenant le 1er nombre
    dim y$
    dim r,r1,r2
    dim t$
    dim Ierror
    dim op$
    dim i
    caption 0,"Opérations arithmétiques en base quelconque (entre 2 et 36)"
    alpha 10 : top 10,050 : left 10,150 : font_bold 10 : caption 10,"Base (2 ... 36)"
    edit 11  : top 11,050 : left 11,160+width(10) : width 11,30 : text 11,"2" : set_focus 11
    alpha 20 : top 20,100 : left 20,50 : font_bold 20: caption 20,"1er nombre"
    edit 21  : top 21,100 : left 21,70+width(20)
    alpha 30 : top 30,100 : left 30,80+width(20)+width(21) : font_bold 30 : caption 30,"Second nombre"
    edit 31  : top 31,100 : left 31,10+left(30)+width(30)
    option 40 : top 40,150 : left 40,50 : font_bold 40 : width 40,150 : caption 40,"+ Addition" : mark_on 40
    option 50 : top 50,170 : left 50,50 : font_bold 50 : width 50,150 : caption 50,"- Soustraction"
    option 60 : top 60,190 : left 60,50 : font_bold 60 : width 60,150 : caption 60,"* Multiplication"
    option 70 : top 70,210 : left 70,50 : font_bold 70 : width 70,150 : caption 70,"/ Division entière"
    option 80 : top 80,230 : left 80,50 : font_bold 80 : width 80,150 : caption 80,"^ Exponentiation"
    button 90 : top 90,300 : left 90,150 : font_bold 90 : caption 90,"Calcul" : on_click 90,calcul
    button 99 : top 99,300 : left 99,300 : font_bold 99 : caption 99,"Quitter" : on_click 99,Fin
    op$ = left$(caption$(40),1)
    for i = 40 to 80 step 10 : on_click i,opt : next i
END_SUB
rem ============================================================================
Opt:
  op$ = left$(caption$(number_click),1)
return
rem ============================================================================
Calcul:
   t$ = upper$(text$(11))
   if numeric(t$) = 0
      message "La base doit être comprise entre 2 et 36 !"
      return
   end_if
   ib = val(t$)
   x$ = upper$(text$(21))
   if x$ = ""
      message "Le 1er nombre ne peut pas être vide !!!"
      return
   end_if

   DecodeBase(x$,ib)
   r1 = r
   x$ = upper$(text$(31))
   if x$ = ""
      message "Le second nombre ne peut pas être vide !!!"
      return
   end_if
   DecodeBase(x$,ib)
   r2 = r
   if Ierror = 0
      if op$ = "+" then r1 = r1 + r2
      if op$ = "-" then r1 = abs(r1-r2)
      if op$ = "*" then r1 = r1*r2
      if op$ = "/"
         if r2 = 0 then message "ERREUR : Division par zéro !!!" : return
      end_if
      if op$ = "^" then r1 = power(r1,r2)
      r = r1
      CodeBase(r,ib)
      if Ierror = 0
         message "Résultat : " + y$
      else
         message "ERREUR dans le codage du résultat !!!"
      end_if
   else
      message "ERREUR : Nombre invalide ou erreur de décodage !!!"
   end_if

return
rem ============================================================================
Fin:
   terminate
rem ============================================================================
' Convertir le nombre x$ de la base ib à la base 10
' La procédure retourne 1 dans la variable globale Ierror si ib n'est pas dans
' l'intervalle [2..36] ou si la chaine x$ contient des caractères invalides dans
' la base ib ou si le résultat r est très grand.
' Sinon, elle retourne 0 si tout est correct.
SUB DecodeBase(x$,ib)
    dim_local xmult,ch$,long,i,j
    Ierror = 1
    if (ib < 2) or (ib > 36)
       message "La base doit être comprise entre 2 et 36 !"
       exit_sub
    end_if
    r = 0 : xmult = 1
    long = len(x$)
    for i = 1 to long
        ch$ = mid$(x$,long+1-i,1)
        if (asc(ch$) < asc("0")) or (asc(ch$) > asc("Z")) or ((asc(ch$) > asc("9")) and (asc(ch$) < asc("A")))
           exit_sub
        end_if
        if asc(ch$) <= asc("9")
           j = asc(ch$) - asc("0")
        else
           j = asc(ch$) - asc("A") + 10
        end_if
        if j >= ib then exit_sub
        r = r + xmult * j
        if xmult > XmaxReal / ib then exit_sub
        xmult = xmult * ib
    next i
    ierror = 0
END_SUB
rem ============================================================================
' Convertir le nombre r de la base 10 à la base ib
' La procédure retourne 1 dans la variable globale Ierror si ib n'est pas dans
' l'intervalle [2..36]
' Sinon, elle retourne 0
SUB CodeBase(r,ib)
    dim_local x,n
    Ierror = 1
    if (ib < 2) or (ib > 36)
        message "La base doit être comprise entre 2 et 36 !"
       exit_sub
    end_if
    y$ = "" : x = r
    while "Papydall" = "Papydall"
        if x <= 0 then Ierror = 0 : exit_sub
        n = int(x-ib*int(x/ib))
        if n < 0 then exit_sub
        if n < 10
           y$ = chr$(asc("0") + n) + y$
        else
           y$ = Chr$(Asc("A") + n-10)+y$
        end_if
        x = INT(x/ib)
    end_while
    Ierror = 0
END_SUB
rem ============================================================================

print power(100,1000) : ' <--- Erreur Externe. 'INF' is not a valid floating point value

rem ============================================================================
rem               Base1_to_Base2.bas
rem                 Par Papydall
rem ============================================================================
rem Traduire un nombre exprimé dans une base quelconque en une autre base.
rem ============================================================================
' Les bases de départ et d’arrivée doivent être supérieures ou égales à 2 sinon
' mathématiquement elles n’ont pas de sens !
' Une base b quelconque nécessite b symboles pour être représentée.
' Toutefois, les notations dans les bases supérieures à 10 utilisent les premières
' lettres de l’alphabet :
' A représente la valeur suivant 9 (donc le « 10 » décimal),
' B celle qui suit A (soit le « 11 » décimal), et ainsi de suite.
' Il sera donc difficile (seulement en pratique et non mathématiquement parlé !)
' de dépasser la base 36.
' Cette dernière nécessite en effet les 10 chiffres de 0 à 9 et les 26 lettres de A à Z.
' Vous pouvez taper les lettres indifféremment en minuscules ou en majuscules.
rem ============================================================================
' Remarque :
' Le programme donne la valeur du nombre dans la base de départ, dans la base
' décimale et dans la base d’arrivée.
' Pour vous amuser
' Essayez de traduire un nombre de la base 36 à la bas 2.
' Donnez comme nombre à convertir TOUTES LES LETTRES et TOUS LES CHIFFRES.

rem ============================================================================
label demarrer,quitter
dim base1         : ' base de départ
dim base2         : ' base d'arrivée
dim Nb_convert$   : ' nombre à convertir
dim Nb10          : ' nombre traduit en base 10
dim puiss1,puiss2 : ' puissances successives de base1 et de base2
dim l             : ' nombre de chiffres de Nb_convert$
dim flag          : ' drapeau indiquant la validité des chiffres
dim r$            : ' chiffre à traduire en base 10
dim nt$           : ' traduction en base d'arrivée
dim d             : ' indice des diviseurs
dim i             : ' indice de boucle de calcul
dim r             : ' valeur en base 10 du chiffre r$
dim bidon$        : ' c'est une variable bidon, quoi !

Go()

end
rem ============================================================================
SUB Go()
    application_title "CONVERSION DES BASES"
    caption 0,"CONVERSION DE BASES PAR PAPYDALL"
    width 0, 800 : color 0,0,0,0 : font_color 0,255,255,0 : font_size 0,12 : font_bold 0
    scene3d 1 : color 1, 0,0,0 : 3d_text 1,"PAPYDALL " : full_space 1 : 3d_color 1,0,0,255
    3d_position 1,-2,-.5,1
    for i = 0 to 360 : 3d_x_rotate 1,i :  wait 1 : next i
    for i = 1 to .01 step -.001 : 3d_scale 1,i,i,i : display : next i
    3d_text 2,"VOUS PROPOSE " : 3d_color 2,255,0,0
    3d_position 2,-3.5,-.5,1
    for i = 0 to 360 : 3d_x_rotate 2,i : wait 1 : next i
    for i = 1 to .01 step -.001 : 3d_scale 2,i,i,i : display : next i
    3d_text 3,"BASE1_TO_BASE2" : 3d_color 3,0,255,0
    3d_position 3,-1.5,-.5,1
    for i = 0 to 500 : 3d_y_rotate 3,i : 3d_z_rotate 3,i : wait 1 : next i
    for i = 1 to .01 step -.001 : 3d_scale 3,i,i,i : display : next i
    hide 1
    print_target_is 0 : font_color 0,255,255,0 : font_size 0, 12 :  print_locate 50,50
    print "CET UTILITAIRE VOUS PERMET DE TRADUIRE UN NOMBRE >= 0"  : print_locate 50,80
    print "EXPRIME DANS UNE BASE QUELCONQUE COMPRISE ENTRE 2 ET 36" : print_locate 50,110
    print "EN UNE AUTRE BASE  EGALEMENT COMPRISE ENTRE 2 ET 36"
    button 10 : top 10,200 : left 10,200 : width 10,150 : caption 10,"DEMARRER"
    button 20 : top 20,200 : left 20,400 : width 20,150 : caption 20,"QUITTER"
    on_click 10,demarrer : on_click 20, quitter
END_SUB
rem ============================================================================
demarrer:
    repeat
        if message_input("CONVERSION DE BASES","BASE DE DEPART (2...36) ","10") = 1
           bidon$  = message_text$
           if numeric(bidon$) = 1 then  base1 = val(message_text$)
       end_if
    until base1 > 1 and base1 < 37

    repeat
        if message_input("CONVERSION DE BASES","BASE D'ARRIVEE (2...36)","2") = 1
           bidon$  = message_text$
           if numeric(bidon$) = 1 then  base2 = val(message_text$)
        end_if
    until base2 > 1 and base2 < 37

    repeat
        if message_input("CONVERSION DE BASE","NOMBRE A CONVERTIR","1") = 1
           bidon$  = message_text$
           Nb_convert$ = upper$(message_text$)
        end_if

        Nb10 = 0 : puiss1 = 1 : l = len(Nb_convert$) : flag = 0
        for puiss2 = l to 1 step -1
           r$ = mid$(Nb_convert$,puiss2,1)
           CHR2ASC()
           if r >= base1 or r < 0 then flag = 1
           Nb10 = Nb10 + puiss1 * r : puiss1 = puiss1 * base1
       next puiss2
    until  flag = 0
    if base1 <> 10
       message "TRADUCTION EN BASE 10 DE " + chr$(13) + Nb_convert$ + " (BASE "+str$(base1) +") : "+ chr$(13) + str$(Nb10)
    end_if
    puiss2 = 1 : d = 1
    repeat
        puiss2 = puiss2 * base2 : d = d + 1
    until puiss2 * base2 > Nb10

    dim v(d)
    puiss2 = 1  : nt$ = ""
    for i = 1 to d : v(i) = puiss2 : puiss2 = puiss2 * base2 : next i
    for i = d to 1 step -1
        r = int(Nb10 / v(i))
        ASC2CHR()
        nt$ = nt$ + r$ : Nb10 = Nb10 - r * v(i)
    next i

    message "TRADUCTION EN BASE " + str$(base2) +" DE " + chr$(13) + Nb_convert$ + " (BASE " + str$(base1)+") : " + chr$(13) + nt$
    free v(d)
return
rem ============================================================================
' Transforme un CHR en ASCII
SUB CHR2ASC()
    r = asc(r$) - 48 : if r > 9 then r = asc(r$) - 55
END_SUB
rem ============================================================================
' Transforme un ASCII en CHR
SUB ASC2CHR()
    r$ = chr$(r + 48) : if r > 9 then r$ = chr$(r + 55)
END_SUB
REM ============================================================================
quitter:
 if message_confirmation_yes_no("VOUS VOULEZ VRAIMENT QUITTER ?") = 1 then terminate
return
rem ============================================================================

rem ============================================================================
rem              Conversion Base 10 <----> Base 256
rem ============================================================================
rem Convertir un entier en chaine de caractères
rem Traduire une chaine de caractères en un nombre en base 10
rem ============================================================================
' Exemple: codage de 64345 en base 256
' 64345 = 251 * 256 ^ 1 + 89 * 256 ^ 0
' Base256 = Chr$(251) + Chr$(89) = "ûY"
Conversion256(64345)            : ' Résultat = ûY
Conversion256(216172782113790)  : ' Résultat = Ä›¥ãSþ
rem ============================================================================
' Exemple: décodage de "+7" en base 10
' Base256 = Chr(43) + Chr(55) = "+7"
' Base10 = 55 * 256 ^ 0 + 43 * 256 ^ 1 = 11063
Conversion10("+7")      : ' Résultat = 11063
Conversion10("Ä›¥ãSþ")  : ' Résultat = 216172782113790
end
rem ============================================================================
SUB Conversion256(Base10)
    dim_local Puissance256,Base256$,cp1,cp2,a%,b10
    ' Valeur maximum pour Base10 = 216172782113790
    if Base10 > 216172782113790
       message "La valeur Maximum pour Base10" +chr$(13)+"ne doit pas dépasser"+chr$(13) + "9223372036854775"
       exit_sub
    end_if
    Puissance256 = 0  : b10 = base10
    Base256$ = ""
    ' Calcul de la puissance en base 256 du nombre en base 10
    CP1 = Base10
    While (CP1 / 256) >= 1
        Puissance256 = Puissance256 + 1
        CP1 = Int(CP1 / 256)
    end_while
    ' Ecriture de la chaîne caractère Base256
    For a% = 0 To Puissance256
        CP2 = int(Base10 / power(256,Puissance256-a%))
        Base256$ = Base256$ + Chr$(CP2)
        Base10 = Base10 - (CP2 * (power(256,Puissance256-a%)))
    Next a%
    ' à la sortie de la fonction, on a le nombre désiré en base 256, soit en mode ASCII 256.
    ' remarque: la plage de caractère va de 0 à 255 et non de 1 à 256.
    message str$(B10) + " = " + Base256$
   ' clipboard_string_copy Base256$
END_SUB
rem ============================================================================
SUB Conversion10(Base256$)
    dim_local Base10,b%,b256$
    Base10 = 0  : b256$ = base256$
    ' Ecriture de la chaîne caractère Base10
    For b% = 0 To Len(Base256$) - 1
        Base10 = Base10 + (Asc(Right$(Base256$, 1)) * power(256, b%))
        Base256$ = Left$(Base256$, Len(Base256$) - 1)
    Next b%
    ' à la sortie, on a le nombre en base 10 tiré d'une chaîne de caractère
    message b256$ +" = " + str$(Base10)
END_SUB
rem ============================================================================