Section courante

A propos

Section administrative du site

Calcul des nombres

Comme vous l'avez déjà découvert, ORIC peut gérer de très grands nombres et aussi de très petits nombres, à la fois positifs et négatifs. Plus les nombres augmentent, plus ils ont besoin de chiffres, donc 10 a besoin de deux chiffres, 100 en a besoin de trois, et ainsi de suite. Cela peut devenir désordonné et difficile à lire et à écrire lorsque le nombre devient très important. Il existe une manière d'écrire les nombres beaucoup plus compacte, appelée notation scientifique ou notation des exposants.

10 peut s'écrire 1x101 (10)
100 peut s'écrire 1x102 (10 x 10)
1000 peut s'écrire 1x103 (10 x 10 x 10)
et ainsi de suite

ORIC pourrait écrire 1x103 comme 1.00000000E+3. En fait, les nombres jusqu'à 999999999 sont généralement affichés tels qu'ils sont normalement écrits, car ORIC est précis à 9 chiffres.

Essayez ceux-ci :

  1. PRINT 999999999*1

alors

  1. PRINT 9999999999*1

Cela vous montre comment fonctionne la notation scientifique, et aussi comment le nombre est arrondi.

Entrez de grands nombres et voyez comment Oric les affiche. Vous pouvez également entrer des nombres tels que 2,3E+4 pour voir quel est leur équivalent. Un moyen facile de se rappeler comment convertir ces nombres est de dire 2.3E+4 signifie «Notez 2.3 Déplacez les chiffres de 4 places vers la gauche. Remplissez tous les espaces avec des zéros» :

2.3
23.0 ← 1 place (ou fois 10)
230.0 ← 2 places (ou fois 100)
2300.0 ← 3 places (ou fois 1000)
23000.0 ← 4 places (ou fois 10000)

Donc 2,3E+4 équivaut à 23000. 2.3E-4 Qu'est-ce que cela signifie ? Le signe négatif après le E ne signifie pas que le nombre est négatif, simplement très petit. Cela signifie : «Notez 2.3 Déplacez les chiffres de 4 cases vers la droite. Remplissez tous les espaces avec des zéros».

2.3
0.23 → 1 place (ou diviser par 10)
0.023 → 2 places (ou diviser par 100)
0.0023 → 3 places (ou diviser par 1000)
0.00023 → 4 places (ou diviser par 10000)

Donc 2,3E-4 est un tout petit nombre : 0,00023. Si le nombre est un grand nombre négatif, il s'écrira - 2.3E+4. Si le nombre est un très petit nombre négatif, il s'écrira -2.3E-4. Assurez-vous de comprendre ces différences si vous souhaitez comprendre comment ORIC gère les nombres.

INT

INT est une fonction renvoyant le plus grand nombre entier inférieur ou égal à la valeur entre parenthèses. Essayez-les pour voir si Oric renvoie les réponses que vous attendez :

  1. PRINT INT(1.5)
  2. PRINT INT(2)
  3. PRINT INT(-2)
  4. PRINT INT(-1.5)

Notez en particulier le résultat du dernier exemple - INT arrondit toujours à un nombre inférieur à celui entre parenthèses, à moins qu'il ne soit déjà un entier.

ABS

ABS renvoie la valeur absolue d'un nombre. S'il est positif, il le reste. S'il est négatif, il devient positif. Essayez ceux-ci :

  1. PRINT ABS(4.3)
  2. PRINT ABS(-4.3)     

SGN

SGN renvoie soit -1,0 soit 1, selon que la valeur entre parenthèses est négative, nulle ou positive. Essayez ceci pour voir comment cela fonctionne :

  1. 10 FOR N=-5 TO 5
  2. 20 PRINT N,SGN(N)
  3. 30 NEXT N

DATA

Si vous avez beaucoup de nombres étant utilisés dans un programme, il est alors possible de les entreposer dans le programme en tant que DATA, plutôt que d'avoir à les saisir à chaque fois. Ce court exemple montre comment intégrer ces informations dans vos programmes :

  1. 10 FOR N=1 TO 5
  2. 20 READ A
  3. 30 S=S+A
  4. 40 NEXT N
  5. 50 PRINT "SOMME = "S
  6. 60 DATA 1,3,8,6,4

La ligne 20 lit (READ) les données (DATA), un élément à la fois, et attribue cette valeur à la variable A. Elle est ajoutée à S (initialement zéro) à chaque fois et affichée à la ligne 50.

Lorsque le programme est exécuté (RUN), un pointeur se déplace le long de chaque élément au fur et à mesure qu'il est lu (READ), et il reste au dernier élément atteint. Si vous tapez GOTO 10, le pointeur n'est pas réinitialisé et vous obtiendrez un message d'erreur OUT OF DATA. RESTORE est une commande réinitialisant le pointeur dans un programme. Ajoutez «15 RESTORE» et voyez l'effet que cela a sur le programme. Le pointeur est réinitialisé sur le premier élément DATA chaque fois que la boucle est exécutée, donc 1 est ajouté à S à chaque fois, et le reste des DATA est ignoré.

Tableaux

Parfois, il est préférable de rassembler des variables similaires au lieu de leur donner des noms différents. Les tableaux ont des parenthèses après la lettre variable afin que vous puissiez identifier un élément. par exemple. N(1),N(2),N(3) et N(4) sont tous des éléments du tableau N.

Oric réserve de l'espace pour jusqu'à 10 éléments dans un tableau, automatiquement. Si vous avez besoin de plus d'espace, vous devrez utiliser l'instruction DIM, par exemple, DIM N(14) réservera de l'espace pour 15 éléments. (Les tableaux commencent par zéro, pas un, dans la plupart des formes de BASIC).

L'une des raisons d'utiliser des tableaux plutôt que de simples variables est qu'ils peuvent facilement tenir dans des boucles FOR/NEXT.

  1. 10 FOR N=1 TO 5
  2. 20 A(N)=N*N
  3. 30 NEXT N
  4. 40 FOR X=1 TO 5
  5. 50 PRINT X,A(X)
  6. 60 NEXT X

Les lignes 10 à 30 chargent le tableau A(N) avec les carrés du numéro de boucle (N). Les lignes 40 à 60 affichent le contenu du tableau à l'écran. Notez qu'il n'est pas nécessaire de remplir chaque élément d'un tableau. Tout élément "vide" contiendra zéro.

Un tableau comme ceux que nous venons de considérer est similaire à une colonne de nombres, mais il est également possible d'avoir des lignes et des colonnes - en d'autres termes, un tableau à deux dimensions. Les tableaux multidimensionnels doivent être dimensionnés avant utilisation.

  1. 10 DIM A(5,5)
  2. 20 FOR N=1 TO 5
  3. 30 FOR M=1 TO 5
  4. 40 A(N,M)=N*M
  5. 50 NEXT M,N

Cela chargera les numéros dans 25 emplacements. Vous pouvez probablement voir dans le programme qu'ils se trouvent être les réponses à des sommes de multiplication simples :

  N
M   0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 1 2 3 4 5
2 0 2 4 6 8 10
3 0 3 6 9 12 15
4 0 4 8 12 16 20
5 0 5 10 15 20 25

Contenu du tableau A(N,M) après exécution du programme.

Les chiffres entre parenthèses identifient l'élément auquel vous souhaitez vous référer et sont appelés indices. Exemple: A(2,3) vaut 6 et A(5,5) vaut 25.

Si vous souhaitez avoir encore plus de dimensions, c'est parfaitement possible. Il est important de se rappeler, cependant, que même DIM N(10,10,10) a 1000 éléments, et vous risquez de manquer de mémoire assez rapidement !

LOGS

Nous mentionnerons que les nombres peuvent être écrits en utilisant la notation scientifique. Par exemple. 1,6E+2 équivaut à 160. Plus généralement, 1,6E+2 s'écrirait 1,6x102, ce qui signifie 1,6x10x10 ou 1,6x100. Le petit 2 sur 102 signifie «écrivez le grand nombre ce nombre de fois et multipliez-les ensemble», par exemple, 10x10.

Donc 104 signifie 10x10x10x10 ou 10 000. Le petit nombre est appelé l'indice ou l'exposant. 104 est généralement lu comme «10 élevé à la puissance de 4» ou simplement «10 à la puissance de 4».

Cela nous donne une introduction aux logarithmes, ou journaux en abrégé, car le journal d'un nombre est la puissance à laquelle 10 doit être élevé pour produire ce nombre. c'est-à-dire que 4 est le logarithme de 10 000.

Pour trouver le logarithme d'un nombre compris entre 1 et 10, il faut trouver l'indice produisant ce nombre. Il doit être compris entre 0+1. Si vous tapez :

  1. PRINT LOG(5)

alors le journal sera renvoyé. Vous devriez obtenir :

0.698970004

Pour vérifier s'il s'agit bien du logarithme de 5, essayez d'élever 10 à cette puissance et voyez si 5 est produit. Taper :

  1. PRINT 10 ↑ 0.698970004

et vois si tu avais raison. (Le signe ↑ signifie "à la puissance de" et est SHIFT+6 sur le clavier). Rappelez-vous 10 logX=x.

En plus des logarithme en base 10 ou communes, il existe également des logarithme naturelles disponibles sur Oric. Taper :

  1. PRINT LN(5)

Tu devrais obtenir :

1.60943791

étant le logarithme naturel de 5. Comment peut-il y avoir plus d'un logarithme ? Les logarithmes de base 10 sont la puissance à laquelle 10 doit être élevé pour produire ce nombre. Les logarithmes naturels sont la puissance à laquelle e doit être élevé pour produire ce nombre. e est :

2.718281828

e est le résultat de cette série :

e = 1 + 1 + ½ + 1/(2x3) + 1/(2x3x4),..., ...

L'exponentielle naturelle d'un nombre est l'inverse du logarithme naturel et peut être obtenue en tapant PRINT EXP(X). Donc X=EXP(LN(X)).

Pour trouver le logarithme d'un nombre à une autre base, utilisez la formule :

LOG base z(X) = LOGe(X)/LOGe(Z)

Log e est bien sûr le même que LN sur Oric.

Bases de nombre

Jusqu'à présent, nous avons rencontré des nombres binaires et des nombres décimaux. Peut-être êtes-vous troublé par tant de façons différentes de représenter les mêmes quantités. En fait, ils ne sont pas vraiment aussi difficiles à comprendre qu'ils n'y paraissent - tout dépend de la façon dont nous choisissons de regrouper les nombres. Normalement, nous regroupons les choses par dizaines - probablement parce que nous avons dix doigts et pouces - il n'y a pas d'autre raison probable. Tout notre système de comptage utilise des groupes de dix. Lorsque nous avons dix groupes de dix, cela forme une centaine, et dix centaines forment un millier et ainsi de suite.

Par exemple, 3742 est composé de 3 milliers, 7 centaines, 4 dizaines et 2 unités. Le plus grand chiffre que vous pouvez avoir dans n'importe quelle colonne est 9. Un de plus, et vous avez assez pour un groupe de 10 dans la colonne suivante.

Exemple :

 9
+1
__
10
__

Supposons que les humains aient 8 doigts et 8 pouces. Ils auraient utilisé ces symboles : 0, 1, 2, 3, 4, 5, 6 et 7. 8 et 9 n'existeraient pas.

 7
+1
__
10
__

Le chiffre le plus grand que vous pouvez maintenant avoir dans n'importe quelle colonne est 7. Un de plus fait un groupe de huit, donc la réponse est 10. Cela ne se lit pas comme "dix" mais "un-zéro" en "base huit". Pour montrer qu'il ne s'agit pas d'un nombre normal (ou décimal ou dénaire ou en base 10), alors il est d'usage de l'écrire 10.

Tout comme les entêtes de colonne des nombres en base 10 sont en dizaines :

Unités Milliers Centaines Dizaines
  (10x10x10) (10x10) (10)

donc en base huit, les titres sont en huit :

Unités 512 64 8
  (8x8x8) (8x8) (8)

donc 1241, est le même que (1x512) + (2x64) + (4x8) + 1 = 673 en base 10.

Dans le langage de l'ordinateur, binaire ou base 2, les mêmes règles s'appliquent - mais maintenant il n'y a que 2 chiffres, 0 + 1 et les regroupements sont par deux :

Unités 16 8 4 2
  (2x2x2x2) (2x2x2) (2x2) (2)

Donc en binaire, le nombre 10111 est le même que :

1 x 16) + (0 x 8) + (1 x 4) + (1 x 2) + 1 = 23 en base 10

Cela peut devenir assez lourd lorsque de grands nombres sont impliqués. En face, il faut 8 chiffres pour faire 255, et 65535 est 1111111111111111 - seize chiffres !

Il serait possible d'ignorer le code binaire pour les grands nombres et de s'en tenir à la base 10, mais cela ne donnerait aucune indication sur la façon dont le nombre a été entreposé sur un ordinateur.

Un compromis est atteint en utilisant la base seize (ou hexadécimal ou hexadécimal comme on l'appelle plus généralement). La base 16 a besoin de 16 chiffres, donc les lettres sont utilisées au-dessus de 9. Cela signifie que compter en hexadécimal donne ceci :

0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F

Vous pouvez voir que quinze en hexadécimal est F, et donc seize est 10. Cela donne les entêtes de colonne comme suit :

Unités 4096 256 16
  (16x16x16) (16x16) (16)

Donc 12AF en hexadécimal, est le même que :

(1 x 4096) + (2 x 256) + (10 x 16) + 15 = 4783 en base 10

Pourquoi choisir un système de numération aussi horrifiant ? Vous l'avez peut-être deviné - il montre en un coup d'oeil comment les nombres sont entreposés dans un ordinateur, en prenant des blocs de quatre bits à la fois.

F0 peut être entreposé dans un octet :

  F    0
____ ____
1111 0000

L'énorme nombre binaire équivalant à 65535 en base 10 devient FFFF en hexadécimal. Vous pouvez maintenant voir pourquoi 65535 est l'emplacement mémoire le plus élevé que vous pouvez adresser en utilisant deux octets.

Oric reconnaîtra les nombres hexadécimaux comme tels, à condition qu'ils soient précédés d'un #, prononcé «dièse». Donc PRINT #1A produit 26. Essayez quelques conversions par vous-même. Le plus grand nombre que vous pouvez convertir est #FFFF.

Remarque : Vous pouvez trouver des livres identifiant les nombres hexadécimaux en utilisant un $, mais Oric interprétera cela comme un signe de chaîne de caractères.

Si vous avez besoin de convertir entre des nombres hexadécimaux et en base 10, vous utiliserez #. c'est à dire :

  1. PRINT #10

produira 16.

Pour convertir un nombre décimal ou en base dix en une chaîne de caractères contenant la valeur et précédée d'un #, tapez :

  1. PRINT HEX$(16)

Cela produira #10. Comme pour #, il y a une limite supérieure de 65535 c'est-à-dire #FFFF. Ce programme affichera les nombres en base 10 jusqu'à 255 ainsi que leur équivalent hexadécimal.

  1. 10 FOR N=0 TO 255
  2. 20 PRINT N,HEX$(N)
  3. 30 NEXT N

Routines mathématiques

Bien qu'il soit important de ne pas considérer les ordinateurs uniquement comme des manipulateurs de nombres, il ne fait aucun doute qu'ils effectuent de nombreuses tâches mathématiques généralement ennuyeuses et répétitives, relativement simples. Oric a de nombreuses routines intégrées aidant à «calculer les chiffres».

Si vous aviez besoin de connaître toutes les racines carrées de 1 à 100, vous devriez passer beaucoup de temps à chercher dans les tableaux ou à appuyer sur les touches de la calculatrice. Oric peut y parvenir beaucoup plus simplement. Tapez dans ce programme :

  1. 10 CLS
  2. 20 FOR N=1 TO 100
  3. 30 PRINT N, SQR(N)
  4. 40 NEXT N

Si vous l'exécutez, les nombres de 1 à 100 clignoteront sur le côté gauche de l'écran, avec leurs racines carrées à côté d'eux au centre de l'écran. Oric les calcule si vite que vous avez probablement eu du mal à les lire. Mettez-y :

  1. 35 WAIT 10

pour ralentir le programme.

Oric peut même calculer les racines sans utiliser la fonction SQR. Il existe une méthode de recherche de racines appelée la méthode itérative de Newton-Raphson. L'itération signifie continuer à faire la même chose encore et encore - une utilisation idéale pour une boucle sur Oric. A chaque fois, la supposition s'affine et se rapproche de la bonne réponse. Ce programme court montre les suppositions et s'arrête lorsque la réponse est correcte. (La ligne 80 saute hors de la boucle si la supposition est à moins de t 0,000001 de la bonne réponse - juste au cas où il n'y aurait pas de réponse exacte) :

  1. 5 REM *** RACINES ITERATIFS ***
  2. 10 INPUT "PENSEZ A UN NUMERO";S
  3. 20 INPUT "DEVINEZ LA RACINE";G
  4. 30 PRINT G
  5. 40 X=S/G 
  6. 50 G=(X+G)/2
  7. 60 R=G*G
  8. 70 IF R<(S+0.000001) AND R>(S-0.000001) THEN GOTO 90
  9. 80 GOTO 30
  10. 90 PRINT"RACINE = ";G     

Il existe une autre utilisation du cerveau mathématique à grande vitesse d'ORIC. Le mathématicien Leibnitz du 17e siècle, ayant rendu le calcul possible, a découvert une façon de calculer π. π est un nombre irrationnel ; en d'autres termes, il ne peut jamais être calculé à un nombre fini de décimales. Leibnitz a découvert que cette séquence se rapprochait de plus en plus de la vraie valeur.

π ≈ 4(1 - 1/3 + 1/5 - 1/7 + 1/9 + ...) ...

Vous devriez être en mesure de voir un motif régulier dans les fractions. ORIC aime les motifs, car ils peuvent être mis en boucles. Si vous deviez essayer de calculer la formule a ci-dessus avec un crayon et du papier, cela vous prendrait beaucoup de temps, même jusqu'à - 1/9. - d'autant plus mauvais quand on se rend compte que la réponse n'est pas assez proche tant qu'on n'a pas bouclé plusieurs centaines de fois. Pauvre Leibnitz, mais chanceux ! Essayez ce programme :

  1. 5 REM *** PI LENT ***
  2. 10 CLS
  3. 20 DEF FNA(N)=(-1/N+1/(N+2))
  4. 30 FOR X=3 TO 10003 STEP 4
  5. 40 S=S+FNA(X)
  6. 50 APPROX=4*(1+S)
  7. 60 PRINT APPROX
  8. 70 NEXT X

La ligne 20 définit une fonction, A, contenant une variable N. Cela évite d'avoir une ligne encombrante plus tard. FNA calcule en fait la série et est appelée à la ligne 30. La boucle monte par étapes de 4, en commençant par 3, donc X est 3, 7, 11, 15,... Cela fait des incréments corrects et le résultat est affiché à la ligne 50. Si vous exécutez (RUN) le programme, Oric affichera un résultat pour π se rapprochant de plus en plus du résultat réel. Comparez-le avec 3.1416 et vous verrez que ce n'est pas le moyen le plus rapide de calculer π, même avec ORIC. Pour trouver π un peu plus rapidement, tapez simplement :

  1. PRINT PI     

Cela vous donnera une valeur précise de 71 à plusieurs décimales, car PI est entreposé comme une constante par ORIC. N'oubliez pas que cela signifie que vous ne pouvez pas choisir PI comme nom de variable, ni aucun mot commençant par PI, tel que PIG = 8 ou PIPES = 78, car PI est un mot réservé.

Nombres aléatoires

Il existe une fonction utile sur ORIC étant souvent utilisée dans les programmes de jeux. Il s'agit de RND, renvoyant un nombre pseudo-aléatoire. En raison de la façon dont les ordinateurs génèrent des nombres aléatoires, cela ne sera pas vraiment aléatoire et il serait possible de découvrir un modèle dans la série de nombres produits. Cela ne sera probablement pas évident à moins que vous n'effectuiez une analyse statistique sur la série, de sorte que le RND peut, à toutes fins normales, être considéré comme vraiment aléatoire.

Si vous n'êtes pas sûr de ce que sont les nombres aléatoires, envisagez un dé. Il a une chance égale de produire des nombres de 1 à 6. L'ordre dans lequel les nombres sont réellement produits dans une série de lancers est aléatoire. Pour simuler cela sur ORIC, essayez ce programme :

  1. 5 REM *** LANCEUR DE DES ***
  2. 10 FOR N=1 TO 10
  3. 20 PRINT"APPUYEZ SUR N'IMPORTE QUELLE TOUCHE POUR LANCER LE DE"
  4. 30 GET A$
  5. 40 A = INT(RND(1)*6) + 1
  6. 50 PRINT A
  7. 60 NEXT     

La ligne 20 attend qu'une touche soit enfoncée. La ligne 30 choisit un nombre aléatoire entre 0 + 1, le multiplie par 6, la fonction INT perd toute fraction décimale, et enfin, 1 est ajouté. Cela garantit qu'un nombre de 1 à 6 sera produit.

RND(n) produira un nombre aléatoire supérieur ou égal à 0 et inférieur à 1, si n est un nombre positif. Si n est un nombre négatif, alors la graine aléatoire est définie sur un nombre particulier, et les n positifs suivants produiront toujours la même séquence. Si n vaut zéro, le dernier nombre aléatoire généré sera produit.

Pour conclure cette page, voici un programme utilisant plusieurs des fonctions mentionnées dans cette page. Il utilise également certaines routines de gestion de chaînes de caractères que vous ne comprendrez peut-être pas entièrement tant que vous n'aurez pas lu la page correspondante. Si nécessaire, revenez-y plus tard. Les calendriers sont difficiles à construire en raison de la maladresse de la terre à ne pas prendre un nombre exact de jours pour passer autour du soleil. En fait, il faut 365,242216 jours pour faire une année exacte.

Diverses personnes, de Numa Pomilius et Jules César au pape Grégoire, ont tenté de corriger le calendrier, mais il n'est toujours pas parfait.

Tout cela rend plus compliqué le calcul du jour de la semaine auquel une date particulière est tombée. Le mathématicien allemand Gauss a élaboré une formule fonctionnant pour n'importe quelle date à partir de 1752, lorsque le calendrier grégorien a été lancé au Royaume-Uni et dans les colonies américaines :

  1. 5 REM *** CALCULATEUR DE JOURS ***
  2. 10 CLS
  3. 20 PRINT"ENTRER LA DATE, LE MOIS ET L'ANNEE"
  4. 30 INPUT "DATE";D
  5. 40 IF D<1 OR D>31 THEN 30
  6. 50 INPUT "MOIS";M
  7. 60 IF M<1 OR M>12 THEN 50
  8. 70 INPUT "ANNEE";Y
  9. 80 IF Y<1752 OR Y>8000 THEN 70
  10. 90 M=M-2:IF M<1 THEN M=M+12:Y=Y-1
  11. 100 Y$=STR$(Y)
  12. 110 C=INT(Y/100)
  13. 120 Y=VAL(RIGHT$(Y$,2))
  14. 130 A=INT(2.6*M-0.19) + D + Y + INT(Y/4) + INT(C/4) - C*2
  15. 140 DAY=INT((A/7-INT(A/7))*7 + 0.1)
  16. 150 DAY=DAY + 1
  17. 160 FOR N=1 TO DAY
  18. 170 READ DAY$
  19. 180 NEXT N
  20. 190 PRINT DAY$
  21. 200 DATA DIMANCHE,LUNDI,MARDI, MERCREDI, JEUDI, VENDREDI, SAMEDI

Dernière mise à jour : Mardi, le 7 mars 2023