CalculaTor est une calculatrice réalisée à partir de la suggestion d'un blogueur qui demandant un tel outil pour la distribution Linux Elementary OS.

Grâce à Lazarus, il fonctionne pour tout système Linux. Mais je n'ai même pas soumis ma réalisation, parce que je trouvais que la discussion dérivait ; au nom du « cahier de charges » d'Elementary et de toutes sortes de sottises de la productivité moderniste, toutes les bonnes idées étaient abandonnées et l'on revenait à une calculette à boutons qu'il faut cliquer, juste un peu plus jolie que celle de Windows… La bêtise est au pouvoir à un très haut niveau, et le culte du travail d'équipe institutionalise le triomphe de la médiocrité.

Ce « projet » était un prétexte pour apprendre à faire une fiche sans bords qu'on puisse déplacer, avec une image comme fond. Il n'y a aucun bouton, mais des images cliquables. Le clic droit à n'importe quel endroit de la fiche affiche un menu déroulant permettant de choisir le séparateur décimal, de choisir de garder la fiche au-dessus ou non, d'afficher le log des calculs, de le sauvegarder ou de le restaurer. On saisit les chiffres au clavier, on peut déclencher le calcul avec Enter ; la flèche permet de transférer le résultat de la deuxième fenêtre dans la première. Les réglages choisis (séparateur décimal et maintien au-dessus) ainsi que les logs sont sauvegardés dans le dossier de l'exécutable (Windows) ou dans le dossier utilisateur (Linux).

L'idée du blogueur, qui est un graphiste, était, à mon avis, de supprimer un clavier inutile et gênant (il prend trop de place sur l'écran et on est tenté de cliquer les touches, ce qui est peu productif, puisqu'on peut aussi, avec les calculettes fournies par les différents OS, taper les chiffres au clavier), et de fournir une application occupant assez peu de place sur l'écran pour pouvoir y rester. Je l'ai fait démarrer en haut à droite de l'écran et par défaut elle reste au-dessus des autres fenêtres pour être disponible quand on utilise un autre logiciel. Les options sont configurables. La seule entorse au principe du clavier seul est la flèche que j'ai ajoutée plus tard pour transférer le résultat, mais on peut ne pas l'utiliser. Comme toutes les applications, on peut la fermer par Alt-F4 si elle a le focus, bien sûr.

Le seul bouton utilisé est invisible : il mesure zéro pixel de large et il permet d'activer la touche Enter pour effectuer l'opération. Les algorithmes de calcul pourraient être améliorés peut-être.

Il faudrait introduire les parenthèses pour avoir un calcul sur le modèle algébrique. Ça me forcerait apparemment à transformer en fonction la procédure de calcul et à faire un premier passage de cette fonction sur les seules opérations entre parenthèses, puis un deuxième passage sur toute la chaîne d'opérations où j'aurais remplacé le contenu des parenthèses par les résultats obtenus au premier passage.

La méthode utilisée est vraiment peu satisfaisante, puisque le Pascal sait effectuer ces expressions numériques et toutes ces lectures visant à traduire des caractères en nombres seraient supprimées si j'arrivais à envoyer directement au Pascal l'expression numérique. J'ai l'impression que c'est possible et la seule raison qui m'a découragé d'insister dans ce sens est que tous les exemples de calculatrices en Pascal que j'ai vus passaient par des chaînes de caractères. Mais ces exemples comportaient des claviers virtuels.

Comme, en dépit de ma médiocre programmation, cet outil me sert souvent et que j'ai souvent besoin d'élever un nombre à la puissance n, j'ai ajouté l'opérateur ^, qui élève le résultat des opérations précédentes à la puissance indiquée.

1er mai 2016 : pas pu m'empêcher d'ajouter aussi la racine nième, puisque la racine n de x est x^(1/n), et pouvait donc déjà être obtenue par la même fonction presque sans changement (s'il y avait eu des parenthèses, notamment). On pose l'opération comme ceci pour \/2: 2r2 -> 1,41421356237309. Racine seizième de 65536 : 65536r16 -> 2. (mais il y a plus de décimales sur la calculette scientifique de Windows).

Comme le signe ^ est pénible à atteindre sur le clavier français, on peut désormais taper p à la place. Il sera remplacé par ^ au moment du calcul…

Si j'avais eu ça en 1963 pour mes TP de physique au lieu d'une règle à calcul…

Mais toujours pas de parenthèses.

J'aurais aussi besoin de conversions hexa, octal et binaires, peu accessibles sur les calculettes scientifiques des systèmes d'exploitation. C'est assez facile mais ça ajouterait des boutons comme de petits 10, 16, 8 et b (ou d, h, o, b) à droite de l'edit de droite. Ça relève peut-être d'un projet différent…

Voici la procédure de calcul actuelle :

Code :Sélectionner tout -Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
procedure TForm1.Calculate(Sender: TObject);
  var
  i: integer=0; //indice de boucle
  j: integer=0; //index incrémenté après chaque opération
  {tableaux dynamiques :
  op : opérateurs ; nombre : chaînes représentant les nombres ; nb : nombres lus}
  op: array of char;
  nombre: array of string;
  nb: array of double;
  resultat: double=0; //ou Extended ?
  FSettings: TFormatSettings;
begin
     FSettings := FormatSettings;
     FSettings.DecimalSeparator:=DS;
     Edit1.Font.Color:=clBlack;
     Edit1.Text := Corrige (Edit1.Text);
     // Dimensionner les tableaux au plus juste
     setlength (op, CntOp(Edit1.Text));
     setlength (nb, CntOp(Edit1.Text) + 1);
     SetLength (nombre, CntOp(Edit1.Text) + 1);
 // setlength (nombre, 16);
  for i:=0 to length (Edit1.Text) do
    begin
      {If (Edit1.Text[i] in ['*','/']) and (Edit1.Text[i+1] in ['+','-'])
      then nombre[j+1] := nombre[j+1] + '(' + Edit1.Text[I+1] + Edit1.Text[i+2] + ')';}
      if Edit1.Text[i] in ['0'..'9', DS] then nombre[j]:=nombre[j]+Edit1.Text[i];
      // lire aussi le dernier nombre non suivi d'un opérateur
      if i = length (Edit1.Text) then nb[j] := strtofloat(nombre[j], FSettings);
      if Edit1.Text[i] in['+', '-', '*', '/', '^', 'r'] then
      begin
        op[j]:=Edit1.Text[i];
        nb[j]:=strtofloat(nombre[j], FSettings);
        //try  except ShowMessage('erreur') end;
        j:=j+1;
      end;
    end;
// nombres et opérateurs collectés, on effectue
resultat:=nb[0];
    for i:=1 to high(nb) do
      begin
      if ((op[i-1] = '/') and (nb[i] = 0)) then
      begin ShowMessage ('Division par zéro impossible'); exit end;
             case op[i-1] of
            '+': resultat:=resultat+nb[i];
            '-': resultat:=resultat-nb[i];
            '*': resultat:=resultat*nb[i];
            '/': resultat:=resultat/nb[i];
            '^': resultat:=power (resultat, nb[i]);
            'r': resultat:=power (resultat, (1/nb[i]));
            end;
      end;
Edit2.Text:=FloatToStr(resultat, FSettings);
Edit1.SelStart:=Length(Edit1.Text);
    {Si op est * ou / et précédent + ou -, mettre des parenthèses}
  //  If (Edit1.Text[i] in ['*', '/']) and (Edit1.Text[i+1] in ['+', '-'])
  //  then s:=s+'('+Edit1.Text[i]+')';
Memo1.Text := Memo1.Text + Edit1.Text + #10 + '= ' + Edit2.Text + #10;
If (MontreLg and (Memo1.Height < 500)) then
begin
     Form1.Height := 60 + 20 + (Memo1.Lines.Count*17);
     Memo1.Height := 20 + (Memo1.Lines.Count*17);
end
end;