Forum TI-Planet.org

Hmm oui je pensais a une version standalone, dans le simple but d'avoir une version a jour de l'existant qui se fait vieux. La convivialité des outils n'etant pas le but ici, juste histoire d'avoir quelque chose de plus récent, et ca pourrait servir lors de benchmarks/comparaisons ; et en effet la version avec les nouvelles features/modules en ressortirait davantage gagnante je suppose, mais bref, c'est pas mon point ici
En tout cas j'aii informé Vogtinator des derniers posts en date de ce topic.

J'ai mis a jour le source, il manquait l'ajout de l'extension .tns apres .py pour les imports de fichiers. J'ai aussi renomme linalg.mult en linalg.mul (en coherence avec les noms de methodes) et complete numpy.py.tns (cf ci-dessous). Ca devrait donner une assez bonne compatibilite avec numpy, mais il y a quelques differences qui sont il me semble impossible a enlever: a.T pour avoir la transposee de a, je ne vois pas comment faire sans une methode ou un appel de fonction, ce sera a.T() ou transpose(a), il y a aussi le redimensionnement, impossible d'utiliser un membre, je cree une fonction reshape.

Il est surement possible de completer et ameliorer, vu que je ne suis pas du tout un expert en Python:

Code: Tout sélectionner

import linalg
import math
class array:
    def __init__(self, a):
        self.a = a
 
    def __add__(self, other):
        return array(linalg.add(self.a , other.a))
 
    def __sub__(self, other):
        return array(linalg.sub(self.a , other.a))
 
    def __mul__(self, other):
        if type(self)==array:
            if type(other)==array:
                return array(linalg.mul(self.a , other.a))
            return array(linalg.mul(self.a,other))
        return array(linalg.mul(self,other.a))
   
    def __rmul__(self, other):
        if type(self)==array:
            if type(other)==array:
                return array(linalg.mul(self.a , other.a))
            return array(linalg.mul(self.a,other))
        return array(linalg.mul(self,other.a))

    def __matmul__(self, other):
        return __mul(self,other)

    def __getitem__(self,key):
        r=(self.a)[key]
        if type(r)==list or type(r)==tuple:
            return array(r)
        return r

    def __setitem__(self, key, value):
        if (type(value)==array):
            (self.a)[key]=value.a
        else:
            (self.a)[key]=value
        return None

    def __len__(self):
        return len(self.a)
   
    def __str__(self):
        return "array("+str(self.a)+")"
 
    def __neg__(self):
        return array(-self.a)

    def __pos__(self):
        return self
   
    def __abs__(self):
        return array(linalg.abs(self.a))

    def __round__(self):
        return array(linalg.apply(round,self.a,linalg.matrix))

    def __trunc__(self):
        return array(linalg.apply(trunc,self.a,linalg.matrix))

    def __floor__(self):
        return array(linalg.apply(floor,self.a,linalg.matrix))

    def __ceil__(self):
        return array(linalg.apply(ceil,self.a,linalg.matrix))

    def T(self):
        return array(linalg.transpose(self.a))
           
def real(x):
    if type(x)==array:
        return array(linalg.re(x.a))
    return x.real

def imag(x):
    if type(x)==array:
        return array(linalg.im(x.a))
    return x.imag

def conj(x):
    if type(x)==array:
        return array(linalg.conj(x.a))
    return linalg.conj(x)

def sin(x):
    if type(x)==array:
        return array(linalg.apply(math.sin,x.a,linalg.matrix))
    return math.sin(x)

def cos(x):
    if type(x)==array:
        return array(linalg.apply(math.cos,x.a,linalg.matrix))
    return math.cos(x)

def tan(x):
    if type(x)==array:
        return array(linalg.apply(math.tan,x.a,linalg.matrix))
    return math.tan(x)

def asin(x):
    if type(x)==array:
        return array(linalg.apply(math.asin,x.a,linalg.matrix))
    return math.asin(x)

def acos(x):
    if type(x)==array:
        return array(linalg.apply(math.acos,x.a,linalg.matrix))
    return math.acos(x)

def atan(x):
    if type(x)==array:
        return array(linalg.apply(math.atan,x.a,linalg.matrix))
    return math.atan(x)

def sinh(x):
    if type(x)==array:
        return array(linalg.apply(math.sinh,x.a,linalg.matrix))
    return math.sinh(x)

def cosh(x):
    if type(x)==array:
        return array(linalg.apply(math.cosh,x.a,linalg.matrix))
    return math.cosh(x)

def tanh(x):
    if type(x)==array:
        return array(linalg.apply(math.tanh,x.a,linalg.matrix))
    return math.tanh(x)

def exp(x):
    if type(x)==array:
        return array(linalg.apply(math.exp,x.a,linalg.matrix))
    return math.exp(x)

def log(x):
    if type(x)==array:
        return array(linalg.apply(math.log,x.a,linalg.matrix))
    return math.log(x)

def size(x):
    if type(x)==array:
        return linalg.size(x.a)
    return linalg.size(x)

def shape(x):
    if type(x)==array:
        return linalg.shape(x.a)

def dot(a,b):
    return a*b

def transpose(a):
    if type(x)==array:
        return array(linalg.transpose(x.a))

def trn(a):
    if type(x)==array:
        return array(linalg.conj(linalg.transpose(x.a)))
    return linalg.conj(linalg.transpose(x.a))

def zeros(n,m=0):
    return array(linalg.zeros(n,m))

def ones(n,m=0):
    return array(linalg.ones(n,m))

def eye(n):
    return array(linalg.eye(n))

def det(x):
    if type(x)==array:
        return linalg.det(x.a)
    return linalg.det(x)

def inv(x):
    if type(x)==array:
        return linalg.inv(x.a)
    return linalg.inv(x)

def solve(a,b):
    if type(a)==array:
        if type(b)==array:
            return array(linalg.solve(a.a,b.a))
        return array(linalg.solve(a.a,b))
    if type(b)==array:
        return array(linalg.solve(a,b.a))
    return linalg.solve(a,b)

def eig(a):
    if type(a)==array:
        r=linalg.eig(a.a)
        return array(r[0]),array(r[1])
    return linalg.eig(a)

def linspace(a,b,c):
    return array(linalg.linspace(a,b,c))

def arange(a,b,c=1):
    return array(linalg.arange(a,b,c))

def reshape(a,n,m):
    if type(a)==array:
        return array(linalg.matrix(n,m,a.a))
    return linalg.matrix(n,m,a)


J'ai ajoute un tableur dans KhiCAS. On peut y acceder depuis le shell KhiCAS par le menu des applications (menu 1 1) ou par le raccourci ctrl puis s ou t (comme spreadsheet ou tableur).
La touche calculatrice (en-dessous de esc) permet de configurer le tableur. Les menus de la touche menu et de shift 1 a 8 affiches en bas permettent de faire certaines operations, par exemple on entre des donnees puis on selectionne 2 colonnes puis menu shift 2 scatterplot puis on valide puis on fait shift 6 pour visualiser.
On peut inserer un tableau de valeurs d'une fonction avec shift 3 tablefunc, et d'une suite recurrente avec shift 3 tableseq (la touche tab ou doc permet de voir l'aide sur ces commandes et de saisir un exemple).
Evidemment, l'interet d'avoir ce tableur peut paraitre faible par rapport a celui de la nspire cx cas (il y a quand meme la generation de graphiques dans le tableur qui me semble-t-il n'existe pas chez TI), mais sur une nspire cx (non CAS), ca permet d'avoir un tableur formel. Et surtout ca devrait permettre d'avoir un tableur bientot sur les Numworks N0110, si la faible quantite de memoire vive disponible ne pose pas trop de problemes de portage (a raison de quelques centaines d'octets par cellule, ca va vite...).

Bien joué!

Mais si, sur Nspire, on peut plotter les données d'un tableur (et/ou de l'app D&S) plutot facilement, cf. https://education.ti.com/-/media/D4D35C ... 9E94CAFF20 (notamment avec le Quick Plot) et https://education.ti.com/html/webhelp/n ... istics.htm

Ca parait quand meme complique et tres dependant du logiciel utilise.
Inversement, dans KhiCAS, on fait un nuage de points ou une droite de regression lineaire comme on fait une somme ou une moyenne dans un tableur, on choisit une cellule libre pour y placer une formule, on tape =, on selectionne la commande (sum ou mean ou scatterplot ou linear_regression_plot, qu'on choisit dans le menu shift 1 ou shift 2) puis la zone du tableur (par exemple A1:B10). C'est systematique. Le seul truc qui depend de KhiCAS c'est la maniere d'afficher le graphique (shift 6 ici, c'est rappele dans les fast menus en bas).

Pas vraiment en fait, on le voit peut être pas mais on peut choisir librement la liste pour les abscisses et ordonnées. C'est juste que les applications dédiées sont plus pratique pour interagir avec de telles listes. Mais elles peuvent très bien être éditées/créés/remplies ailleurs.

Mise a jour de https://www-fourier.univ-grenoble-alpes.fr/~parisse/ti/khicas.zip
La principale amelioration est la coloration syntaxique et le parenthese match dans le shell (et dans le tableur), ainsi que les tooltips. Ainsi, si on tape ap les completions s'affichent, fleche vers la droite permet de completer et ctrl ans recopie le 1er exemple, fleche vers le bas ou tab affiche la liste des completions ou directement l'aide sur la commande s'il y a une seule completion possible.
L'interpreteur MicroPython s'enrichit aussi d'un module arit pour faire de l'arithmetique (comme dans Khicas pour Numworks).
Les menus rapides sont accessibles de la meme maniere sur la nspire et sur la Numworks: shift suivi d'une des 12 touches du pave numerique (0 a 9, . et (-) sur la Nspire ou x10^x sur la Numworks) ou shift ( ou shift ), je vais peut-etre essayer de rediger une doc commune.
Ce serait bien de pouvoir echanger des sessions entre Numworks et Nspire, mais il y a 2 problemes: le nom d'extension qui est complete par .tns sur la Nspire, et le support par le workshop Numworks d'autres extensions que .py).

Mise a jour, l'aide et les menus devraient etre nettement plus coherents (a defaut d'etre complets) en mode MicroPython.

Fantastique tout ça !
Mais quel crève-cœur que ce soit inutilisable en mode examen en France.

Niveau compatibilité des scripts, je m'attendais à quelque chose de proche du Micropython pour Ndless. Mais non, j'ai quelques difficultés...

Voici ci-dessous un code unique qui marche sur :

• Micropython / TI-Nspire Ndless
• NumWorks
• Casio Graph 90+E / 35+E II
• Casiopython / Casio Graph 35+E/USB / 75/85/95
• TI-83 Premium CE Python
• CAS / HP Prime
• KhiCAS / Graph 90+E
• HP Prime alpha

En théorie c'est compatible KhiCAS pour Graph 35+E II également, mais en pratique ça dépasse la limite mémoire.

Code: Tout sélectionner

#platforms:
#0: TI-Nspire Ndless
#1: NumWorks
#2: G90+E / G35+E II
#3: G35+E/USB / G75/85/95
#4: TI-83PCE/84+CE
#5: CAS / HP Prime
#6: KhiCAS / Graph 90+E
#7: KhiCAS / Graph 35+E II
#8: HP Prime

def get_pf():
  c256 = True
  try:
    if chr(256)==chr(0):
      if "HP" in version():
        return 5
      else:
        return 6 + (not white)
  except:
    c256 = False
  try:
    import sys
    try:
      if sys.platform=='nspire':
        return 0
      if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':
        return 4
    except:
      return 3
  except:
    pass
  if not c256:
    return 2
  try:
    import kandinsky
    return 1
  except:
    try:
      import hpprime
      return 8
    except:
      pass
  return -1

pf=get_pf()

def get_pf_infos(pf):
  #NumWorks big: 12.5x30
  #NumWorks small: 16x42
  #HP Prime medium: 14x39 11.5x39
  #HP Prime small: 18.5x45 15.5x45
  #HP Prime big: 11x35 9x35
  l_vlines = (29,12,07,09,11,14,09,07,12)
  l_vcols =  (53,30,21,32,32,39,30,19,39)
  b_vcr = 0b100011001
  if pf >= 0:
    return l_vlines[pf], l_vcols[pf], b_vcr // 2**pf % 2
  else:
    return max(l_vlines), max(l_vcols), 1
pf_vlines, pf_vcols, pf_vcr = get_pf_infos(pf)

def sgn(x):
  return (x > 0) - (x < 0)

def fi_same_exp(fi1, fi2):
  while fi1[1] > fi2[1]:
    fi1[1] -= 1
    fi1[0] *= 10
  while fi2[1] > fi1[1]:
    fi2[1] -= 1
    fi2[0] *= 10

def fi_simpl(fi0):
  while fi0[0] and not (fi0[0] % 10):
    fi0[0] = fi0[0] // 10
    fi0[1] += 1
  return fi0

def fi_add(fi1, fi2):
  fi_same_exp(fi1, fi2)
  return [fi1[0] + fi2[0], fi1[1]]

def fi_sub(fi1, fi2):
  fi_same_exp(fi1, fi2)
  return [fi1[0] - fi2[0], fi1[1]]

def fi_mul(fi1, fi2):
  return [fi1[0] * fi2[0], fi1[1] + fi2[1]]

def fi_div(fi1, fi2, n=0):
  fi_simpl(fi2)
  while len(str(fi1[0])) < n:
    fi1[0] *= 10
    fi1[1] -= 1
  s = sgn(fi1[0]) * sgn(fi2[0])
  return [abs(fi1[0]) // abs(fi2[0]) * s, fi1[1] - fi2[1]]

def fi_pi(n):
  fi4 = [4, 0]
  return fi_mul(fi4, fi_sub(fi_mul(fi4, fi_atgi([5, 0], n)),fi_atgi([239, 0], n)))

def fi_atgi(fi0, n):
  fi1 = [1, 0]
  fir = fi_div(fi1, fi0, n)
  f , fie, fik, fix, fi0 = True, fi1, [3, 0], fir, fi_mul(fi0, fi0)
  while fie[0]:
    fix = fi_div(fix, fi0)
    fie = fi_div(fix, fik)
    if f:
      fir = fi_sub(fir, fie)
    else:
      fir = fi_add(fir, fie)
    fik[0] += 2
    f = not f
  return fir

def fi_str(fi0, n=0):
  fi0, s, sr = list(fi_simpl(fi0)), "", sgn(fi0[0])
  fi0[0] = abs(fi0[0])
  while fi0[1] > 0 or len(str(fi0[0])) < n:
    fi0[0] *= 10
    fi0[1] -= 1
  while fi0[0] or fi0[1] <= 0:
    fi0[1] += 1
    s = str(fi0[0] % 10) + s
    if fi0[1] == 0: s = "." + s
    fi0[0] = fi0[0] // 10
  if sr < 0:
    s = "-" + s
  return s

def printautocr(s):
  if pf_vcr:
    print(s)
  else:
    while len(s):
      print(s[:pf_vcols])
      s = s[pf_vcols:]

def demo(n=pf_vlines*pf_vcols - 3):
  xdigits, s = 2, fi_str(fi_pi(n), n)
  s = s[:-xdigits] + "(" + s[-xdigits:] + ")"
  printautocr(s)

Entre le mode CAS HP Prime et KhiCAS pour Graph 90+E, j'en ai eu des réécritures astucieuses de lignes à faire pour que ça passe sur toutes les plateformes.

Et bien non, contre toute attente, KhiCAS pour TI-Nspire Ndless malgré son Micropython hautement plus standard, ne fait que me signaler des erreurs de syntaxe, je ne comprends pas. Pourrais-je avoir un petit indice ? Merci.

Oups, il y avait un probleme dans l'appel au lexer/parser de micropython, ca ne marchait qu'avec un seul statement (en mode ligne de commande), je l'ai passe en mode fichier

Code: Tout sélectionner

execute_from_lexer(LEX_SRC_STR, line, MP_PARSE_FILE_INPUT, true)

et ca a l'air OK maintenant, l'archive de KhiCAS devrait etre a jour.