CONTENUTO SCHEDE P101

___________________________________________________________________ 001: Esempio di somma

"V" a “V” b Il programma stampa n1= a+b, n2 = a-b, n3 = a x b e poi la somma n = n1+n2+n3; se n è positivo ne estrae la radice quadrata, altrimenti calcola il quoziente a/b. Programma TEST1 dell’emulatore dell’Università di Amsterdam

___________________________________________________________________ 002: Fattoriale

"Z" n stampa n! (tratto dal libro di Bell “Computer Structures: Readings and Examples”) Programma TEST4 dell’emulatore dell’Università di Amsterdam

L’originale del libro

___________________________________________________________________ 003: Equazione ridotta di 3° grado (ax3+bx+c=0)

"V" a "S" b "S" c � radice (positiva) Programma TEST2 dell’emulatore dell’Università di Amsterdam

___________________________________________________________________ 004: Medie mobili (a 5 dati)

Questo esempio illustra le tecniche di rotazione dei registri (nel manuale inglese viene chiamata “Domino Technique”). "V" n1 "S" n2 "S" n3 "S "n4 "S" n5

Tratto dal “Reference Manual” pag. 52

L’originale del manuale

___________________________________________________________________ 005: Arc cos x (in radianti)

"V" x “S” Programma TEST3 dell’emulatore dell’Università di Amsterdam

___________________________________________________________________ 006: Cos x e Sec x (in gradi)

"V" x “S” . A secondo del valore in D (π, 180, 200) l’angolo può essere impostato in radianti, gradi – come nella scheda sotto – e gradi centesimali).

___________________________________________________________________ 007: Exp x

Dalla “Biblioteca di Programmi” vol. 1 – programma n. 5 "V" x “S” stampa esponente di 10 e mantissa

___________________________________________________________________ 008: 10^x

Dalla “Biblioteca di Programmi” vol. 1 – programma n. 4 "V" x “S” stampa esponente di 10 e mantissa

___________________________________________________________________ 009: Sen x e Cosec x (in gradi)

"V" x “S” . A secondo del valore in D (π, 180, 200) l’angolo può essere impostato in radianti, gradi – come nella scheda sotto – e gradi centesimali).

Rotella Decimale: 6

___________________________________________________________________ 010: Sen x, Cos x, Tan x

"V" x → sin x; "W" → cos x; "Z" → tan x. A secondo del valore in D (π/2, 90, 100) l’angolo può essere impostato in radianti, gradi – come nella scheda sotto – e gradi centesimali).

Rotella Decimale: 10

___________________________________________________________________ 011: Ln x

Dalla “Biblioteca di Programmi” vol. 1 – programma n. 2

"V" x “S”

___________________________________________________________________ 012: Log x (x = base * 10^esponente)

Dalla "Biblioteca di Programmi" vol. 1 – programma n. 1 "V" esponente "S" base "S" --> stampa log Esempio: Per calcolare log 500 = 5 *102

"V" 2 "S" 5 "S" � 2.69896998

___________________________________________________________________ 013: Velocità del pistone

Programma TEST5 dell’emulatore dell’Università di Amsterdam La formula usata è la seguente: / λ sin 2Θ \ v= rm | sin Θ + ------------------ | con λ=rm/lb \ 2√(1- λ ²sin²Θ) / Rotella decimali: 6 Vanno riempiti a mano i registri

• C (rm - raggio di manovella) • C/ (costante 1) • D/ (Θ iniziale – NON zero)

poi lb (lunghezza di biella) "V" Nota: sin Θ viene calcolato con una serie di Tchebychev (vedi scheda #9)

_____________________________EQUIVALENTE BASIC______________________________ DEFDBL A-Z pi = ATN(1) * 4 CLS INPUT "Raggio di manovella"; rm INPUT "Lunghezza di biella"; lb lambda = rm / lb FOR theta = 0 TO 180 STEP 1 theta1 = theta * pi / 180 'angolo in radianti vel = rm * (SIN(theta1) + lambda * SIN(2 * theta1 ) / 2 / SQR(1 - lambda ^ 2 * SIN(theta1) ^ 2)) PRINT theta; vel NEXT theta

___________________________________________________________________ 014/015: parabola dei minimi quadrati (y=axb)

#14: "V" poi Xi "S" Yi "S" "Z" stampa risultato #15: "S" stampa parametri curva tratto dal “Reference Manual” pag. 54-60

14

15

___________________________________________________________________ 016: Radice cubica (tratto da programmi di Meccanica: utile come subroutine)

"V" poi n stampa radice cubica di n

___________________________________________________________________ 017: Trave appoggiata con carico concentrato intermedio: calcolo deformazioni elastiche

Programma n. 58 da “Esercitazioni di calcolo automatico - sez. Elettronica

/Elettrotecnica” La trave ha lunghezza l (il carico è in x=a � l=a+b) P=carico, J=momento di inerzia, E=modulo di elasticità "V" poi a "S" b "S" P "S" J "S" E stampa le rotazioni θ(A) e θ(B) impostare x, premere "S" si calcola Y(x) per ogni x richiesto

___________________________________________________________________ 018: Retta di regressione (y=ax+b)

Calcola la retta di regressione su n coppie di punti (tratto dal "Manuale di Programmazione" pagg. 45-46) "V" poi xi "S" yi "S" "Z" stampa risultati "r","a","b"

___________________________________________________________________ 019: Logaritmo Naturale lnx

Calcola ln x per x assegnato (subroutine isolata dalla scheda #135) x "V" lascia il risultato in A

___________________________________________________________________ 020: "Radici equazione 3° grado"

Il programma risolve x3+bx2+cx+d=0 (tratto da "Biblioteca di programmi" - vol. 1 programma n. 34)

"V" b "S" c "S" d "S" stampa le radici (la prima sempre reale: quelle complesse sono date come Re{x} e Im{x})

___________________________________________________________________ 021: "Determinante matrice 3x3"

(tratto da "Biblioteca di programmi" - vol.1 programma n.25) │ a11 a12 a13 │ │ a21 a22 a23 │ │ a31 a32 a33 │ a11 "V" a12 "S" a13 "S"........ a33 "S" stampa determinate

___________________________________________________________________ 022: "Sistema lineare 3x3"

(tratto da "Biblioteca di Programmi" - vol. 1 programma n. 40) ┌ │ a1 x1 + b1 x2 + c1 x3 = k1 ┤ a2 x2 + b2 x2 + c2 x3 = k2 │ a3 x1 + b3 x2 + c3 x3 = k3 └ "V" a1 "S" b1 "S" c1 "S" k1 "S" ...... k3 "S" stampa le soluzioni x1,x2,x3.

Notare le istruzioni R/* e RS ai passi 009-010: la prima non è dettagliata in nessun manuale.

___________________________________________________________________ 023: "Retta di regressione y=ax+b"

(tratto da "Biblioteca di Programmi" - vol. 1 programma n. 40) "V" xi "S" yi "S" - per tutte le coppie (xi,yi) "Z" stampa r (coeff. correlazione), b ed a

___________________________________________________________________ 024: "Piano di ammortamento progressivo a rata costante"

(tratto da "Manuale di Istruzioni Interne Riservate" #1/4) Rotella decimale: decimali di i più uno "V" C0 "S" i "S" n "S" --> stampa lo sviluppo per gli n periodi

___________________________________________________________________ 025: "Calcolo coefficiente correlazione lineare di Pearson"

(tratto da "Manuale di Istruzioni Interne Riservate" #2/4) Calcolo il coefficiente di correlazione lineare di Pearson per coppie di dati (xi,yi) - versione ridotta del #23 "V" xi "S" yi "S" - per tutte le coppie (xi,yi) "W" stampa r (coeff. correlazione)

___________________________________________________________________ 026: "Radici reali equazione di II° grado"

(tratto da "Manuale di Istruzioni Interne Riservate" #3/4) Calcola le radici reali dell'equazione di secondo grado ax²+bx+c=0 e stampa un singolo "0" se complesse "V" a "S" c "S" b "S" (notare l’ordine dell’input dei dati….)

___________________________________________________________________ 027: "Calcolo di seno e coseno con una serie di Tchebycheff"

(tratto da "Manuale di Istruzioni Interne Riservate" #4/4) Calcola seno e coseno di un angolo in qualsiasi unità angolare (a seconda del valore del registro D) angolo "V" --> seno oppure angolo "W" --> coseno

___________________________________________________________________ 028: "Calcolo di exp(x)"

(esempio #4 del "Programmier Handbuch") Calcola il valore di exp(x) a 15 decimali. "F" "Z" x "S" --> exp(x)

___________________________________________________________________ 029: "Calcolo espressione con subroutine"

(esempio #5 del "Programmier Handbuch") Calcola il valore di una espressione usando una nuova istruzione di subroutine - non riportata nei manuali italiani e americani. Nota: la sub segnata con AW fornisce un'interessante espressione per il calcolo di lnx. "V" x "S" y "S" z "S" --> valori

___________________________________________________________________ 100: Equazione di 2° grado (ax2+bx+c=0)

"V" a "S" b "S" c "S" � x1,x2 o Im(x),Re(x)

___________________________________________________________________ 101: Tabella di fattoriali

"Z" n "S" e viene stampata da n a 1 la tabella dei fattoriali.

___________________________________________________________________ 102: Gioco alto-basso (codificatore)

"V" generatore "S" tentativo "S" P101 fornisce 1 o -1 se il tentativo è alto o basso, o il numero di mosse se si indovina

Per ripetere "V" ↓ "Y".

___________________________________________________________________ 103: Gioco alto-basso (decodificatore) "V" 1 o -1 "S" se il numero proposto è alto o basso 0 "S" se il numero viene indovinato da P101

___________________________________________________________________ 104: Equazione di 3° grado (della forma x3+bx2+cx+d=0)

"V" b "S" c "S" d "S" vengono stampate le soluzioni. Se c'è una interlinea dopo la prima soluzione, i due dati seguenti rappresentano la parte reale e la parte immaginaria delle due soluzioni complesse.

_____________________________EQUIVALENTE BASIC______________________________ DEFDBL A-Z CLS epsilon = .00000001#: r4 = 0 INPUT "B="; b: r1 = b INPUT "C="; c: r2 = c INPUT "D="; d: r3 = d 10 : r6 = r1 r6 = r6 + r4 r6 = r6 * r4 r5 = r6 r5 = r5 + r6 r6 = r6 + r2 r5 = r5 + r2 r6 = r6 * r4 r5 = r5 + r4 ^ 2 r6 = r6 + r3 r6 = r6 / r5 r4 = r4 - r6 IF ABS(r6) > epsilon THEN 10 PRINT r4 r1 = r1 + r4 r3 = r3 / r4 r1 = -r1 / 2 r3 = r3 + r1 ^ 2 IF r3 < 0 THEN PRINT PRINT r1: PRINT SQR(ABS(r3)) ELSE PRINT r1 + SQR(r3): PRINT r1 - SQR(r3) PRINT END IF

___________________________________________________________________ 105: Terne pitagoriche

"V" stampa terna pitagorica "S" e così via.

_____________________________EQUIVALENTE BASIC______________________________ CLS r0 = 4 10 r1 = r0 PRINT r0 temp = (r0 / 2) ^ 2 - 1 r1 = r1 + temp PRINT temp temp = temp + 2 PRINT temp r1 = r1 + temp PRINT 99 IF INKEY$ = "" THEN 99 r0 = r0 + 1 PRINT r0 PRINT r1 PRINT r1 + 1 PRINT r0 = r0 + 1 GOTO 10

___________________________________________________________________ 106: potenze intere A^n "V" n "S" A "S"

___________________________________________________________________ 107: Radice n-sima di A con il metodo di Newton

Calcola la radice n-sima di A con il metodo di Newton. Utile come sequenza di calcolo da utilizzare in altri programmi. "V" n "S" A "S" x0 (numero di innesco) "S"

_____________________________EQUIVALENTE BASIC______________________________ CLS INPUT "A"; A# INPUT "N"; N% INPUT "X0"; X0# 99 : TEMP# = X0# ^ N% X1# = X0# - (TEMP# - A#) / (N% * TEMP# / X0#) PRINT X1# IF ABS(X0# - X1#) <> 0 THEN X0# = X1#: GOTO 99

___________________________________________________________________ 108/109: Annualità Ordinaria

La formula usata è PMT = PV / (1-(1+i)-n)/i "V" PV "S" i "S" n "S" viene stampato lo sviluppo dell’ammortamento.

_____________________________EQUIVALENTE BASIC______________________________ CLS INPUT "Capitale"; c# INPUT "Interesse"; i# INPUT "Anni"; n% orig# = c# 'rem calcolo rata (annualità ordinaria) pmt# = c# / ((1 - (1 + i#) ^ -n%) / i#) PRINT pmt# us$ = " ## ########## ########## ########## # ######### ##########" PRINT " n rata quota int. quota cap. de b.residuo deb.estinto" PRINT " ------------------------------------------- ----------------------" FOR kl% = 1 TO n% qi# = c# * i# qc# = pmt# - qi# dr# = c# - qc# de# = orig# - dr# PRINT USING us$; kl%; pmt#; qi#; qc#; dr#; de# c# = c# - qc# NEXT kl%

___________________________________________________________________ 109: Annualità Ordinaria

Questa contiene una versione ottimizzata tratto dal depliant della P203. Stesse istruzioni d’uso della #108.

___________________________________________________________________ 110: Scomposizione in numeri primi

"V" n → stampa tutti i fattori

_____________________________EQUIVALENTE BASIC______________________________ CLS INPUT "Num."; n# 99 : IF n# - INT(n# / 2) * 2 = 0 THEN PRINT 2; : n# = n# / 2: GOTO 99 k# = 3 98 : IF n# - INT(n# / k#) * k# = 0 THEN PRINT k#; : n# = n# / k#: GOTO 99 k# = k# + 2#: IF k# > SQR(n#) THEN PRINT n#: STOP GOTO 98

___________________________________________________________________ 111: Simulatore per atterraggio lunare

"V" visualizza v/h/f (velocità, altezza ed unità di carburante) imposta carburante "S" ricalcolo parametri

(tradotto dall’identico programma per HP-9100)

_____________________________EQUIVALENTE BASIC______________________________ CLS gl = 5 'gravità lunare in ft/sec^2 sarebbe 5.15 v = -50: x = 500: f = 120 10 PRINT v, x, f INPUT "Carburante"; carb carb = ABS(carb) IF carb > f THEN GOTO 49 acc = carb - gl 'la forza di gravità accelera la na vetta v.nuovo = v + acc x.nuovo = x + v + acc / 2 f.nuovo = f - carb IF x.nuovo < 0 THEN GOTO 55 v = v.nuovo: x = x.nuovo: f = f.nuovo: GOTO 10 49 : v = SQR(v * v + 2 * gl * x) 55 : PRINT v, 0, -999999

___________________________________________________________________ 112: Risolve il gioco dell’inversione (“Reverse”)

Rotella Decimale: 0 Imposta numero da invertire "V": vengono stampate tutte le mosse. Nota: Il numero impostato indica le cifre da invertire partendo da destra. Ad esempio partendo da 147893265 con la mossa 3 si ottiene 147893562).

_____________________________EQUIVALENTE BASIC______________________________ CLS r& = 357982146 PRINT r& n = 1 ' numero da cercare 5 : posiz = 1 ' posizione inziale a& = 0 ' forma la parte di numero da invertire f& = 1 ' moltiplicatore ' trova la posizione del numero n-simo 10 : last = (r& / 10 - INT(r& / 10)) * 10 a& = a& * 10 + last: r& = INT(r& / 10): f& = f& * 1 0 IF last - n > 0 THEN posiz = posiz + 1: GOTO 10 PRINT posiz; r& = r& * f& + a& PRINT r& ' ribalta il numero dalla posizione n (r &) a& = 0: f& = 1: posiz = 10 - n PRINT posiz; 40 : last = (r& / 10 - INT(r& / 10)) * 10: r& = INT (r& / 10) a& = a& * 10 + last: f& = f& * 10: posiz = posiz - 1: IF posiz > 0 THEN 40 r& = r& * f& + a& PRINT r& n = n + 1: IF 10 - n > 0 THEN GOTO 5

___________________________________________________________________ 113-114: Master Mind (codificatore - 4 cifre diverse tra 0 e 9)

Il programma è a due schede: la scheda 113 genera il numero segreto; la scheda 114 gestisce le risposte del codificatore. Con la scheda 113 impostare un numero positivo inferiore a 1 con 4-6 decimali e premere "Z": vengono così generate le 4 cifre (tra 0 e 9 e tutte diverse l'una dall'altra) da indovinare. Con la scheda 114 mettere a zero la ruota decimale, premere "V" e poi impostare il tentativo: la risposta è un numero a due cifre (la prima è il numero delle cifre al posto giusto, la seconda il numero delle cifre giuste al posto sbagliato). Il numero viene indovinato quando la risposta è 40. N.B: se la risposta di P101 è un numero con una sola cifra N, questa va letta come 0N (cioè N cifre giuste al posto sbagliato).

113

_____________________________EQUIVALENTE BASIC______________________________

' codificatore DEFINT A-Z b = -1: b1 = -1: c = -1: c1 = -1 CLS INPUT "Gen="; gen# i = 0 50 i = i + 1 60 gen# = (gen# + SQR(3)) ^ 6: gen# = gen# - IN T(gen#) PRINT gen# r = INT(gen# * 10) IF ABS(r - c1) > 0 THEN 101 GOTO 60 101 IF ABS(r - c) > 0 THEN 102 GOTO 60 102 IF ABS(r - b1) > 0 THEN 103 GOTO 60 103 IF ABS(r - b) > 0 THEN 104 GOTO 60 104 IF ABS(i - 1) > 0 THEN 105 b = r: GOTO 50 105 IF ABS(i - 2) > 0 THEN 106 b1 = r: GOTO 50 106 IF ABS(i - 3) > 0 THEN 107 c = r: GOTO 50 107 c1 = r

‘---------------- parte B 120 INPUT tent risp = 0 i = 4 130 cifra = tent - INT(tent / 10) * 10 tent = INT(tent / 10) j = 4: IF ABS(c1 - cifra) > 0 THEN 131 GOTO 150 131 j = 3: IF ABS(c - cifra) > 0 THEN 132 GOTO 150 132 j = 2: IF ABS(b1 - cifra) > 0 THEN 133 GOTO 150 133 j = 1: IF ABS(b - cifra) > 0 THEN 170 150 risp = risp + 1: IF ABS(i - j) > 0 THEN 170 risp = risp + 9 170 i = i - 1: IF i > 0 THEN 130 PRINT risp IF ABS(risp - 40) > 0 THEN 120 END 114

___________________________________________________________________ 115: QueenBoard (gioco "Corner the Lady" per HP-67)

Si gioca su una scacchiera standard 8x8 (con le caselle opportunamente numerate ) usando un sola Regina mossa alternativamente dai due giocatori: le caselle di partenza possibili sono quelle della prima riga in alto e quella della colonna più a destra. Vince chi raggiunge per primo la casella in basso a sinistra.

Rotella Decimale: 0 "V" mossa "S" Se P101 risponde con 168 ha vinto il giocatore Se P101 risponde con 158 ha vinto. Regole del gioco: 1) Parte il giocatore scegliendo una delle celle sottoindicate 2) La cella di arrivo è quella in basso a sinistra. 3) La mossa del pezzo è quella della regina, ma solo verso ovest, sud e

diagonale sud-ovest.

Le caselle sono così codificate: *** partenza **** ------------------------------------- ---+ * 81 71 61 51 41 31 21 11 | p -----------------------------------+ | a 92 82 72 62 52 42 32 | 22 | r 103 93 83 73 63 53 43 | 33 | t 114 104 94 84 74 64 54 | 44 | e 125 115 105 95 85 75 65 | 55 | n 136 126 116 106 96 86 76 | 66 | z 147 137 127 117 107 97 87 | 77 | a vincente - ► 158 148 138 128 118 108 98 | 88 | * N.B. 1: La versione non ha controlli sull'input e sul termine del gioco, perché altrimenti avrebbe superato le 120 istruzioni. N.B. 2 : Nella cartella COMPIL è presente il file TEST11.TXT ed il suo corrispondente in BASIC TEST11.BAS (ottenuto con il traduttore P101TOQB) che contiene il programma originale ed è lungo 168 istruzioni.

_____________________________EQUIVALENTE BASIC______________________________ '-------------------------------------------------- ------------- ' queen board tradotto da HP67 ' versione 2 preparata con test e label adatti alla P101 ' il ritorno da subroutine è ottenuto con la variab ile "ritorno" '-------------------------------------------------- ------------- CLS r2 = 0 10 : INPUT "Mossa"; r1 'test per mossa valida IF r2 - r1 > 0 THEN GOTO 10 'test per vince giocatore IF ABS(r1 - 158) THEN GOTO M1 PRINT "Vince giocatore": END M1: r2 = r1: ritorno = 0: GOTO LblE M2: ri = 7 Label1: r2 = r1 + ri * 10 ritorno = 1: GOTO LblE M3: r2 = r2 + ri ritorno = 2: GOTO LblE M4: r2 = ri * 10 + r2 ritorno = 3: GOTO LblE M5: ri = ri - 1: IF ri > 0 THEN GOTO Label1 Label2: r2 = r1 + 10 Label0: PRINT r2 IF ABS(r2 - 158) > 0 THEN GOTO 10 PRINT "Vince PC": END 'test p er vittoria PC LblE: temp = 0 IF ABS(r2 - 158) > 0 THEN GOTO E1 GOTO Label9 E1: IF ABS(r2 - 127) > 0 THEN GOTO E2 GOTO Label9 E2: IF ABS(r2 - 126) > 0 THEN GOTO E3 GOTO Label9 E3: IF ABS(r2 - 75) > 0 THEN GOTO E4 GOTO Label9 E4: IF ABS(r2 - 73) > 0 THEN GOTO E5 GOTO Label9 E5: IF ABS(r2 - 44) > 0 THEN GOTO E6 GOTO Label9 E6: IF ABS(r2 - 41) > 0 THEN GOTO E7 Label9: IF ritorno > 0 THEN GOTO Label0 GOTO Label2 E7: IF ritorno - 2 > 0 THEN GOTO M5 IF ritorno - 1 > 0 THEN GOTO M4 IF ritorno > 0 THEN GOTO M3 GOTO M2

___________________________________________________________________ 116: CercaQuadrati

Rotella Decimale: 0 Il programma cerca tutti i numeri i cui quadrati sono composti da tutte e nove le cifre diverse (0 escluso). "V" inizia la ricerca: vengono tutti i numeri richiesti con i loro quadrati.

_____________________________EQUIVALENTE BASIC______________________________ 'versione risolta senza l'uso dell'array C(.) 'e preparata per P101 con test e salti DEF fnArrot# (x#, n%) = INT(x# * 10# ^ n% + .501#) / 10# * n% DEFINT A-Z k = 1 CLS ''''''''''''''''''DIM c(0 TO 9) i = 10002 97 : IF i - 31620 > 0 THEN GOTO 98 x# = i ^ 2 c# = 9111111111# '''''''''''''''''''''''''''c(0) = -1 '''''''''''''''''''''''''''FOR j = 1 TO 9: c( j) = 0: NEXT 96 : '''''''''''''''''''''''''''DO WHILE x# > 0 zeta# = x# - 10 * INT(x# / 10) j = zeta# IF j > 0 THEN GOTO 95 GOTO 99 95 : tmp# = 1 j = 9 - j Quater95: IF j > 0 THEN GOTO Bis95 GOTO Ter95 Bis95: tmp# = tmp# * 10# j = j - 1: GOTO Quater95 Ter95: a# = INT(c# / tmp#) a# = fnArrot#(a# / 10#, 1) a# = fnArrot#((a# - INT(a#)) * 10#, 1) IF a# > 0 THEN GOTO 94 GOTO 99 94 : c# = c# - tmp# ''''''''''''''''''''''''c(j) = -1 x# = INT(x# / 10) IF x# > 0 THEN GOTO 96 PRINT k; "---->"; i; " "; CDBL(i ^ 2): k = k + 1 99 i = i + 3: GOTO 97

98 END L'esecuzione del programma è molto lunga (oltre un giorno sulla P101 reale) e produce il seguente tabulato: V 11826 B ♦ 139854276 A ♦ 12363 B ♦ 152843769 A ♦ 12543 B ♦ 157326849 A ♦ 14676 B ♦ 215384976 A ♦ 15681 B ♦ 245893761 A ♦ 15963 B ♦ 254817369 A ♦ 18072 B ♦ 326597184 A ♦ 19023 B ♦ 361874529 A ♦ 19377 B ♦ 375468129 A ♦ 19569 B ♦ 382945761 A ♦ 19629 B ♦ 385297641 A ♦ 20316 B ♦ 412739856 A ♦ 22887 B ♦ 523814769 A ♦ 23019 B ♦ 529874361 A ♦ 23178 B ♦ 537219684 A ♦

23439 B ♦ 549386721 A ♦ 24237 B ♦ 587432169 A ♦ 24276 B ♦ 589324176 A ♦ 24441 B ♦ 597362481 A ♦ 24807 B ♦ 615387249 A ♦ 25059 B ♦ 627953481 A ♦ 25572 B ♦ 653927184 A ♦ 25941 B ♦ 672935481 A ♦ 26409 B ♦ 697435281 A ♦ 26733 B ♦ 714653289 A ♦ 27129 B ♦ 735982641 A ♦ 27273 B ♦ 743816529 A ♦ 29034 B ♦ 842973156 A ♦ 29106 B ♦ 847159236 A ♦ 30384 B ♦ 923187456 A ♦

___________________________________________________________________ 117: Determinante matrice 3x3

Il programma calcola il determinante di una matrice 3x3 impostata riga per riga:

│ a b c │ │ d e f │ │ g h i │

"V" a "S" b "S" c "S" d "S" e "S" f "S" g "S" h "S" i "S" e stampa il determinante. (Tratto da un programma RPN per HP-25)

___________________________________________________________________ 118: Scomposizione di n! in fattori primi

Il programma stampa la scomposizione di n! in fattori primi. Viene così fornita, indirettamente, una tabella di tutti i primi inferiori ad n. "V" n poi segue la stampa (nella forma fattore-esponente).

_____________________________EQUIVALENTE BASIC______________________________ DEFLNG A-Z CLS INPUT "Numero"; n p = 2 GOSUB Dividi PRINT n; "! = "; p; "^"; esp; "*"; p = 3 GOSUB Dividi PRINT p; "^"; esp; "*"; Ancora: p = p + 2: IF p > n THEN END GOSUB Primo: IF NOT ok THEN GOTO Ancora: GOSUB Dividi PRINT p; "^"; esp; "*"; GOTO Ancora END Dividi: esp = 0: q = 1 Rifai: q = q * p: IF q > n THEN RETURN esp = esp + INT(n / q) GOTO Rifai RETURN Primo: ok = 0: q = 3 Rif: IF p MOD q = 0 THEN RETURN q = q + 2: IF q < p THEN GOTO Rif ok = -1 RETURN

___________________________________________________________________ 119: Somme di numeri

Il programma dato N calcola le serie di numeri interi consecutivi che hanno per somma N. "V" N "S" vengono stampate le serie

___________________________________________________________________ 120: Potenze di matrici 2x2

Il programma calcola

N │ a a │ │ 11 12 │ │ a a │ │ 21 22 │

con N intero "V" N a11 "S" a12 "S" a21 "S" a22 "S" viene stampata la matrice risposta riga per riga

_____________________________EQUIVALENTE BASIC______________________________ CLS INPUT "Matrice A (per riga)"; a, b, c, d INPUT "Potenza"; n 'matrice risultato e = a: f = b: g = c: h = d FOR i = 2 TO n x = e * a + f * c f = e * b + f * d e = x x = g * a + h * c h = g * b + h * d g = x NEXT i PRINT e, f, g, h

___________________________________________________________________ 121/122: Funzione Gamma

Il programma calcola la funzione gamma(x) con x compreso tra 1 e 70. E' una traduzione dell'equivalente programma per HP-65 ed è composta da due schede. Inserire prima la scheda 121 "V" x "S" e poi la scheda 122 per completare il calcolo "V".

121

122

_____________________________EQUIVALENTE BASIC______________________________ b1# = -.577191652# b2# = .988205891# b3# = -.897056937# b4# = .918206857# b5# = -.756704087# b6# = .482199394# b7# = -.193527818# b8# = .035868343# CLS INPUT "X"; x# g# = 1# 99 : IF x# > 2 THEN x# = x# - 1#: g# = g# * x#: GOT O 99 x# = x# - 1# ''g1# = 1# + b1# * x# + b2# * x# ^ 2 + b3# * x# ^ 3 + b4# * x# ^ 4 + b5# * x# ^ 5 + b6# * x# ^ 6 + b7# * x# ^ 7 + b8# * x# ^ 8 g1# = b7# + x# * b8# g1# = b6# + x# * g1# g1# = b5# + x# * g1# g1# = b4# + x# * g1# g1# = b3# + x# * g1# g1# = b2# + x# * g1# g1# = b1# + x# * g1# g1# = 1 + x# * g1# PRINT g# * g1#

___________________________________________________________________ 123: Area di un poligono

Il programma calcola l'area di un poligono inserendo le coordinate dei vertici xi e yi, date in senso orario per ottenere un’area positiva. "V" xi "S" yi "S" (ripetere per ogni coppia di coordinate) "W" per stampare l'area.

_____________________________EQUIVALENTE BASIC______________________________ CLS A# = 0 INPUT X#, Y# X1# = X#: Y1# = Y# 99 : INPUT X2#, Y2# A# = A# + (X1# + X2#) * (Y1# - Y2#) X1# = X2#: Y1# = Y2# INPUT "Ancora"; A$: IF A$ = "S" THEN GOTO 99 A# = A# + (X2# + X#) * (Y2# - Y#) PRINT A# / 2#

___________________________________________________________________ 124: Orbita di un satellite

Questo programma replica il programma dimostrativo della P101 mostrato alla stampa specializzata prima del BEMA di New York dell'Ottobre 1965. Le formule utilizzate sono state ricavate da uno spezzone di cinegiornale dell'Istituto Luce. Le formule usate sono: dv x m x m ──── = -GM ──── dt r 3 dv y m y m ──── = -GM ──── dt r 3

avendo posto per semplicità di calcolo GM=1 "V" x iniziale "S" y iniziale "S" vx iniziale "S" vy iniziale "S" epsilon "S" cicli "S" epsilon è in secondi, cicli è il numero di cicli prima di stampare la posizione (>=1) Vengono stampate le coordinate x, y : per interrompere premere <Esc>.

_____________________________EQUIVALENTE BASIC______________________________ DEFDBL A-Z ' valori iniziali x = .5: vx = .1: y = 0: vy = 1: eps = .001 CLS INPUT "Cicli"; cicli Lbl2: numcicli = cicli Lbl1: temp = SQR(x * x + y * y): temp = temp * tem p * temp tx = vx - eps * x / temp ty = vy - eps * y / temp x = x + eps * tx y = y + eps * ty vx = tx: vy = ty numcicli = numcicli - 1 IF numcicli > 0 THEN GOTO Lbl1: PRINT x, y GOTO Lbl2

___________________________________________________________________ 125: Calendario perpetuo

Data una data (>1582 e <2500) calcola il giorno della settimana. "V" giorno "S" mese "S" anno stampa un numero tra 0 e 6 (0=domenica, 1=lunedi, ..., 6=sabato) N.B.: Per date inferiori al 1/3/1900 e superiori al 28/2/2100 aggiungere le seguenti costanti: -3 tra 15/10/1582 e 28/2/1700 -2 tra 1/3/1700 e 28/2/1800 -1 tra 1/3/1800 e 28/2/1900 +1 tra 1/3/2100 e 28/2/2200 +2 tra 1/3/2200 e 28/2/2300 +3 tra 1/3/2300 e 28/2/2500

_____________________________EQUIVALENTE BASIC______________________________ DEFDBL A-Z r2 = 30: r3 = 365: r4 = .5625: r5 = -2.5: r7 = 3 DEF fnfrac# (x#) = x# - INT(x#) CLS INPUT "Giorno"; r6: r6 = r6 + 5 INPUT "Mese"; r1: r6 = r6 + FIX(r1 * r4) INPUT "Anno"; r0 r6 = r6 - r2 r6 = r6 + r0 * r3 + r1 * r2 r0 = r0 - 1 r0 = r0 / 4 r6 = r6 + FIX(r0) IF r7 - r1 > 0 THEN GOTO Lbl1: r5 = r5 + fnfrac#(r0) r6 = r6 + FIX(r5) Lbl1: PRINT FIX(r6) MOD 7 ‘x mod y = x –y *(int(x/y)

___________________________________________________________________ 126: Problema dei cubi

Questo programma risolve il problema dei cubi: trovare i numeri di tre cifre in cui la somma dei cubi delle singole cifre sia uguale al numero stesso. In altri termini detto abc il numero dev’essere: a3+b3+c3=100*a+10*b+c "V" stampa i numeri richiesti.

_____________________________EQUIVALENTE BASIC______________________________ CLS : A = 0: B = 0: C = 0 Lbl1: '''FOR A = 0 TO 9 Lbl2: '''FOR B = 0 TO 9 Lbl3: '''FOR C = 0 TO 9 IF A * A * A + B * B * B + C * C * C = 100 * A + 10 * B + C THEN PRINT A; B; C C = C + 1: IF C < 10 THEN GOTO Lbl3 C = 0: B = B + 1: IF B < 10 THEN GOTO Lbl2 B = 0: A = A + 1: IF A < 10 THEN GOTO Lbl3 '''NEXT C, B, A

___________________________________________________________________ 127 Area di poligoni (altra versione dal sito di M.Galeotti)

Il programma calcola l'area di un poligono inserendo le coordinate dei vertici xi e yi, date in senso orario per ottenere un’area positiva. "V" xi "S" yi "S" (ripetere per ogni coppia di coordinate) Viene stampata l'area finora raggiunta dopo ogni coppia x,y (eccetto, ovviamente, la prima). N.B.: Il programma della scheda 123 effettua lo stesso calcolo, ma è più corto di 13 passi.

___________________________________________________________________ 128 Scomposizione in numeri primi (dal sito di M.Galeotti)

Il programma scompone un numero in fattori primi, stampandoli con controllo sul massimo numero scomponibile. "V" numero "S" (vedi anche programma 110 e 129 - che è il #128 semplificato).

___________________________________________________________________ 129 Scomposizione in numeri primi (dal sito di M.Galeotti - modificato)

Il programma scompone un numero in fattori primi stampandoli. "V" numero "S" L’esecuzione avviene in metà tempo rispetto al programma #110.

___________________________________________________________________ 130 Angela Game

Rotella Decimale: 0 Il programma implementa il gioco "Angela Game", anche se per mancanza di spazio non vengono effettuati i check di fine gioco. Per giocare impostare la meta (tra 30 e 100), "V" puntata (tra 1 e 6 e secondo le regole del gioco). E' stato implementato seguendo la pagina del sito "www.piergiorgioperotto.com" che ha una emulazione in JavaScript del programma originale della Programma 101: nella versione data sul sito ci sono due errori da me corretti. Ho anche scritto una versione più aderente alla logica della P101 in Quick Basic (vedi sotto).

N.B.: Nella cartella COMPIL è presente il file TEST17.TXT ed il suo corrispondente in BASIC TEST17.BAS (ottenuto con il traduttore P101TOQB) che contiene il programma con check di fine gioco ed è lungo 132 istruzioni (12 in più del necessario). N.B.2: I check di fine gioco vanno inseriti nella posizione 16 (per il giocatore) e 119 (per la P101).

_____________________________EQUIVALENTE BASIC______________________________ CONST TRUE = -1, FALSE = 0 CLS '---------------- ' set variabili '---------------- primapuntata = 0 reg.A = 0 reg.M = 0 reg.R = 0 reg.B1 = 0 reg.B2 = 0 'b split reg.C1 = 0 reg.C2 = 0 'c split reg.D1 = 0 reg = 0 temp = 0 avvx$ = " - " p101x$ = " - "

puntx$ = " - " isPuntataValida = TRUE fine = 0 contarighe = 6 LOCATE 5, 1: PRINT "Avvers. P101 Punt.Totale" LOCATE 22, 1: PRINT "Registri Simulati P101"; LOCATE 23, 1: PRINT " A. M. R. B. B/ C. C/ D."; DO LOCATE 1, 1 INPUT "Imposta meta"; reg.M IF reg.M < 30 OR reg.M > 100 THEN LOCATE 20, 1: PRINT "META NON VALIDA: introdu rre un numero tra 30 e 100." ELSE EXIT DO END IF LOOP LOCATE 24, 6: PRINT USING "###"; reg.M; value$ = "B1": GOSUB Trasf LOCATE 24, 16: PRINT USING "####"; reg.B1; value$ = "B2": GOSUB Azzera value$ = "C1": GOSUB Trasf primapuntata = 1 DO Reinit: LOCATE 3, 1: INPUT "Puntata"; reg.M reg.M = INT(reg.M) ' rotella decimale a 0 --> solo interi IF (reg.M < 0 OR reg.M > 6) AND primapuntata = 1 T HEN LOCATE 20, 1: PRINT "PUNTATA NON VALIDA: reimpos tare la puntata." GOTO Reinit END IF IF (reg.M < 1 OR reg.M > 6) AND primapuntata = 0 T HEN LOCATE 20, 1: PRINT "PUNTATA NON VALIDA: reimpos tare la puntata." GOTO Reinit END IF LOCATE 20, 1: PRINT SPACE$(79); primapuntata = 0 GOSUB RV2 GOSUB AggiungiRigaPunteggi IF fine = 0 THEN GOSUB ControlloFineGiocoP LOOP UNTIL fine = 1' principale END RV2: value$ = "D1": GOSUB Trasf avvx$ = STR$(reg.D1) value$ = "C2": GOSUB Azzera GOTO RY1 RV3: value$ = "B2": GOSUB Rich value$ = "D1": GOSUB Somma value$ = "B2": GOSUB Scambio puntx$ = STR$(reg.B2) GOSUB ControlloFineGiocoA: IF fine = 1 THEN RETUR N value$ = "B1": GOSUB Rich value$ = "B2": GOSUB Sottr value = 9: GOSUB ConstProgr value$ = "M": GOSUB Div value$ = "R": GOSUB Scambio IF reg.A > 0 THEN GOTO RV4 value$ = "M": GOSUB Somma RV4: value$ = "A": GOSUB Div

value$ = "C1": GOSUB Trasf value$ = "M": GOSUB Somma value$ = "C2": GOSUB Scambio value$ = "C1": GOSUB Rich value = 3: GOSUB ConstProgr value$ = "M": GOSUB Sottr GOSUB ValAss IF reg.A > 0 THEN GOTO RW1 value = 5: GOSUB ConstProgr value$ = "C2": GOSUB Trasf GOTO RY1 RW1: value$ = "M": GOSUB Sottr IF reg.A > 0 THEN GOTO RW2 GOSUB ValAss IF reg.A > 0 THEN GOTO RY1 value$ = "C2": GOSUB Trasf GOTO RY1 RW2: value = 1: GOSUB ConstProgr value$ = "M": GOSUB Sottr IF reg.A > 0 THEN GOTO RW3 value$ = "C2": GOSUB Trasf value = 3: GOSUB ConstProgr value$ = "C1": GOSUB Trasf GOTO RY1 RW3: value$ = "M": GOSUB Sottr IF reg.A > 0 THEN GOTO RW4 value$ = "C2": GOSUB Trasf value = 4: GOSUB ConstProgr value$ = "C1": GOSUB Trasf GOTO RY1 RW4: value$ = "M": GOSUB Sottr value$ = "C1": GOSUB Trasf value$ = "M": GOSUB Somma value$ = "M": GOSUB Somma value$ = "C2": GOSUB Scambio '''''''GOTO RY1 RY1: ' controlla puntata A o P value$ = "D1": GOSUB Rich value$ = "C1": GOSUB Sottr GOSUB ValAss ' se A <> P controlla complemento IF reg.A > 0 THEN GOTO RY2 GOTO RY3 RY2: value = 7: GOSUB ConstProgr value$ = "M": GOSUB Rich value$ = "D1": GOSUB Sottr value$ = "C1": GOSUB Sottr GOSUB ValAss IF reg.A > 0 THEN GOTO RZ1 '''''''GOTO RY3 RY3: value$ = "C2": GOSUB Rich IF reg.A > 0 THEN GOTO RY4 LOCATE 20, 1: PRINT "NON BARARE. Reimpostare la puntata." isPuntataValida = FALSE: RETURN RY4: value$ = "C1": GOSUB Scambio RZ1: value$ = "C2": GOSUB Rich

IF reg.A > 0 THEN GOTO RZ2 GOTO RV3 RZ2: value$ = "B1": GOSUB Rich value$ = "B2": GOSUB Sottr value = 2: GOSUB ConstProgr value$ = "M": GOSUB Sottr IF reg.A > 0 THEN GOTO RZ3 value$ = "D1": GOSUB Rich value$ = "M": GOSUB Sottr GOSUB ValAss IF reg.A > 0 THEN GOTO RZ3 value = 1: GOSUB ConstProgr value$ = "C1": GOSUB Trasf '''''''GOTO RZ3 RZ3: p101x$ = STR$(reg.C1) value$ = "B2": GOSUB Rich value$ = "C1": GOSUB Somma value$ = "B2": GOSUB Scambio puntx$ = STR$(reg.B2) RETURN ControlloFineGiocoA: fine = 0 value$ = "B1": GOSUB Rich value$ = "B2": GOSUB Sottr IF reg.A > 0 THEN RETURN GOSUB ValAss IF reg.A > 0 THEN LOCATE 20, 1: PRINT "HAI PERSO."; : fine = 1: RETURN LOCATE 20, 1: PRINT "HAI VINTO"; : fine = 1: RETURN '''IF reg.A = 0 THEN LOCATE 20, 1: PRINT "HAI VINTO ."; : fine = 1 '''IF reg.A < 0 THEN LOCATE 20, 1: PRINT "HAI PERSO ."; : fine = 1 '''RETURN ControlloFineGiocoP: fine = 0 value$ = "B1": GOSUB Rich value$ = "B2": GOSUB Sottr IF reg.A > 0 THEN RETURN GOSUB ValAss IF reg.A > 0 THEN LOCATE 20, 1: PRINT "HAI VINTO."; : fine = 1: RETURN LOCATE 20, 1: PRINT "HAI PERSO."; : fine = 1: RETUR N '''IF reg.A = 0 THEN LOCATE 20, 1: PRINT "HAI PERSO ."; : fine = 1 '''IF reg.A < 0 THEN LOCATE 20, 1: PRINT "HAI VINTO ."; : fine = 1 '''RETURN AggiungiRigaPunteggi: IF isPuntataValida THEN LOCATE contarighe, 1: PRINT USING "\ \ \ \ \ \"; avvx$; p101x$; puntx$ contarighe = contarighe + 1 ELSE isPuntataValida = TRUE END IF avvx$ = " - ": p101x$ = " - " RETURN '----------------------------- ' subroutine di emulazione '----------------------------- Somma: GOSUB ColE reg.M = reg LOCATE 24, 6: PRINT USING "####"; reg.M; reg.A = reg.A + reg.M LOCATE 24, 1: PRINT USING "####"; reg.A; RETURN

Sottr: GOSUB ColE reg.M = reg LOCATE 24, 6: PRINT USING "####"; reg.M; reg.A = reg.A - reg.M LOCATE 24, 1: PRINT USING "####"; reg.A; RETURN Molt: GOSUB ColE reg.M = reg LOCATE 24, 6: PRINT USING "####"; reg.M; reg.A = reg.A * reg.M LOCATE 24, 1: PRINT USING "####"; reg.A; RETURN Div: temp = reg.A GOSUB ColE reg.M = reg LOCATE 24, 6: PRINT USING "####"; reg.M; reg.A = reg.A / reg.M LOCATE 24, 1: PRINT USING "####"; reg.A; reg.R = temp MOD reg.M LOCATE 24, 11: PRINT USING "####"; reg.R; RETURN Trasf: reg = reg.M GOSUB ColU GOSUB StampaReg RETURN Rich: GOSUB ColE reg.A = reg LOCATE 24, 1: PRINT USING "####"; reg.A; RETURN Scambio: temp = reg.A GOSUB ColE reg.A = reg LOCATE 24, 1: PRINT USING "####"; reg.A; reg = temp GOSUB ColU GOSUB StampaReg RETURN ValAss: reg.A = ABS(reg.A) LOCATE 24, 1: PRINT USING "####"; reg.A; RETURN ConstProgr: reg.M = value LOCATE 24, 6: PRINT USING "####"; reg.M; RETURN Azzera: reg = 0 GOSUB ColU GOSUB StampaReg RETURN ColE: SELECT CASE value$ CASE "A": reg = reg.A CASE "M": reg = reg.M CASE "R": reg = reg.R CASE "B1": reg = reg.B1 CASE "B2": reg = reg.B2 CASE "C1": reg = reg.C1 CASE "C2": reg = reg.C2

CASE "D1": reg = reg.D1 END SELECT RETURN ColU: SELECT CASE value$ CASE "A": reg.A = reg CASE "M": reg.M = reg CASE "R": reg.R = reg CASE "B1": reg.B1 = reg CASE "B2": reg.B2 = reg CASE "C1": reg.C1 = reg CASE "C2": reg.C2 = reg CASE "D1": reg.D1 = reg END SELECT RETURN StampaReg: LOCATE 24, 1: PRINT USING "####"; reg.A; LOCATE 24, 6: PRINT USING "####"; reg.M; LOCATE 24, 11: PRINT USING "####"; reg.R; LOCATE 24, 16: PRINT USING "####"; reg.B1; LOCATE 24, 21: PRINT USING "####"; reg.B2; LOCATE 24, 26: PRINT USING "####"; reg.C1; LOCATE 24, 31: PRINT USING "####"; reg.C2; LOCATE 24, 36: PRINT USING "####"; reg.D1; RETURN

___________________________________________________________________ 131 Calcolo del seno (tramite serie di Taylor - dal sito di M.Galeotti).

Calcola il seno di un angolo assegnato (in gradi). "V" angolo "S"

___________________________________________________________________ 132 Calcolo del coseno (tramite serie di Taylor - dal sito di M.Galeotti).

Calcola il coseno di un angolo assegnato (in gradi). "V" angolo "S" N.B.: Nella versione sul sito i programmi 131 e 132 sono riportati assieme ma la P101 reale non avrebbe mai potuto eseguirli così come sono. Di conseguenza sono stati modificati e separati. Rinunciando alle stampe intermedie è possibile unificare i due programmi.

___________________________________________________________________ 133 Conversioni di basi numeriche (base ≤ 10)

Tratto da un sito Internet. Nel caso ottale ↔ decimale la base 8 è già preimpostata.

• "V" numero "S" per convertire da ottale a decimale

• "W" numero "S" per convertire da decimale a ottale

• "V" base F↑ numero "S" per convertire da base-n a decimale

• "W" base F/↑ numero "S" per convertire da decimale a base-n

Una trascrizione dell’immagine originale è a pagina seguente.

olivetti underwood programma 101 electronic desk computer PROGRAM CARD

001 AV 002 a ↑ 003 d ♦ 004 f ↑ 005 a ↑ 006 rS 007 D ↓ 008 F ↑ 009 Y 010 AW 011 a ↑ 012 rS 013 D ↓ 014 f ↑ 015 a ↑ 016 d ♦ 017 F ↑ 018 Y 019 AY 020 C* 021 a ↑ 022 d ↓ 023 B ↑ 024 S 025 D ↑ 026 BY 027 D ↓ 028 F÷ 029 D ↨ 030 R ↓ 031 Bx 032 C+ 033 C ↨ 034 D ↓ 035 cY 036 C ♦ 037 / ♦ 038 Y 039 bY 040 B ↓ 041 fx 042 B ↨ 043 CY

Title DECIMAL RADIX CONVERSION____________________

______________________________________________________

______________________________________________________

Date Code No. of Cards

No. of Instructions

month year

1 0 4 3

CARD NO. ____________________

OPERATING PROCEDURES

DECIMAL WHEEL SETTING _________ 0________________

A for OCTAL → DECIMAL

1. Push V

2. Enter # to be converted

3. Push S -- Go to 2

B for DECIMAL → OCTAL

4. Push W – Go to 2

C for RADIXn → DECIMAL (n≤ 10)

5. Push V

6. enter radix – push F/↑

7. Go to 2

D for DECIMAL → RADIXn (n≤ 10)

8. Push W

9. enter radix – push F↑

10. Go to 2

___________________________________________________________________ 134/135 Età di una roccia usando il metodo K-Ar

Programma che calcola l'età di una roccia usando il metodo del Potassio-Argo, una volta assegnati una serie di dati iniziali relativi ai valori degli isotopi Ar40, Ar38, Ar38 e K40. L’argomento trattato è una tesi di laurea del 1968 e nell’Appendice IV sono spiegati passo a passo i due programmi con tutte le formule. Interessante è l’uso di una routine che calcola il logaritmo naturale di un numero memorizzato in un registro numerico (B nel nostro caso - passi 80-112 del programma #135); tratto dal libro “Mathematical

Programming on the Programma 101”. 134

135

___________________________________________________________________ 136 Tabella di potenze (verifica dell'emulatore da un filmato sull'uso della P101)

Questo programma stampa la tabella delle potenze (intere) di un numero assegnato fino alla condizione di overflow (luce rossa accesa). "V" numero "S" per la stampa

136

Questo il risultato dell'elaborazione per n=12

Nota: la rotella dei decimali può essere fissata a sapere (2 decimali nel nostro caso).

L'elaborazione sulla macchina reale.

___________________________________________________________________ 137 Tabella di Fibonacci

Questo programma stampa la tabella dei numeri di Fibonacci da 1 fino alla condizione di overflow (luce rossa accesa). Rotella decimale qualsiasi, ma è consigliato metterla a 0 per avere fino al più grande numero di Fibonacci stampabile. 1 "V"

A pagina seguente il risultato dell'elaborazione (su tre colonne per motivi di spazio). Da notare l'ultimo risultato (F107) del registro A che ha 23 cifre dando quindi luogo all'overflow che blocca l'elaborazione

V 1 A ♦ 2 A ♦ 3 A ♦ 5 A ♦ 8 A ♦ 13 A ♦ 21 A ♦ 34 A ♦ 55 A ♦ 89 A ♦ 144 A ♦ 233 A ♦ 377 A ♦ 610 A ♦ 987 A ♦ 1597 A ♦ 2584 A ♦ 4181 A ♦ 6765 A ♦ 10946 A ♦ 17711 A ♦ 28657 A ♦ 46368 A ♦ 75025 A ♦ 121393 A ♦ 196418 A ♦ 317811 A ♦ 514229 A ♦ 832040 A ♦ 1346269 A ♦ 2178309 A ♦ 3524578 A ♦ 5702887 A ♦ 9227465 A ♦ 14930352 A ♦ 24157817 A ♦ 39088169 A ♦ 63245986 A ♦ 102334155 A ♦ 165580141 A ♦ 267914296 A ♦ 433494437 A ♦ 701408733 A ♦ 1134903170 A ♦ 1836311903 A ♦ 2971215073 A ♦ 4807526976 A ♦ 7778742049 A ♦ 12586269025 A ♦ 20365011074 A ♦ 32951280099 A ♦ 53316291173 A ♦ 86267571272 A ♦

139583862445 A ♦ 225851433717 A ♦ 365435296162 A ♦ 591286729879 A ♦ 956722026041 A ♦ 1548008755920 A ♦ 2504730781961 A ♦ 4052739537881 A ♦ 6557470319842 A ♦ 10610209857723 A ♦ 17167680177565 A ♦ 27777890035288 A ♦ 44945570212853 A ♦ 72723460248141 A ♦ 117669030460994 A ♦ 190392490709135 A ♦ 308061521170129 A ♦ 498454011879264 A ♦ 806515533049393 A ♦ 1304969544928657 A ♦ 2111485077978050 A ♦ 3416454622906707 A ♦ 5527939700884757 A ♦ 8944394323791464 A ♦ 14472334024676221 A ♦ 23416728348467685 A ♦ 37889062373143906 A ♦ 61305790721611591 A ♦ 99194853094755497 A ♦ 160500643816367088 A ♦ 259695496911122585 A ♦ 420196140727489673 A ♦ 679891637638612258 A ♦ 1100087778366101931 A ♦ 1779979416004714189 A ♦ 2880067194370816120 A ♦ 4660046610375530309 A ♦ 7540113804746346429 A ♦ 12200160415121876738 A ♦ 19740274219868223167 A ♦ 31940434634990099905 A ♦ 51680708854858323072 A ♦ 83621143489848422977 A ♦ 135301852344706746049 A ♦ 218922995834555169026 A ♦ 354224848179261915075 A ♦ 573147844013817084101 A ♦ 927372692193078999176 A ♦ 1500520536206896083277 A ♦ 2427893228399975082453 A ♦ 3928413764606871165730 A ♦ 6356306993006846248183 A ♦ 10284720757613717413913 A ♦

___________________________________________________________________ 138 Problema delle Regine

Rotella Decimale: 1 Questo programma risolve il Problema delle Regine per scacchiere di lato n ≤ 9. E’ stato tratto dal sito www.datamuseum.dk dove vengono mostrate tutte le operazioni di recupero di una Olivetti P101. Nei commenti al file "immagine" della scheda sono presenti tutte le informazioni necessarie, compresa l’interpretazione delle soluzioni. Precaricare il registro b/ con un numero alto a piacere (1000 con n=8) e n/10 nel registro B. "V" per partire

Sempre nello stesso sito viene fornito anche l’equivalente in linguaggio “C”. Le istruzioni con "printf" servono solo a scopo di "debugging" e possono essere tolte tranne, ovviamente, quella che stampa le soluzioni. /* * queens.c: Solving the (8-)queens problem, Olivett i P101 style. * 2013-Nov-08 00.52 / TN * * See queen.p101 for explanations. */ #include <stdio.h> #include <stdlib.h> #define n 8 int main() { int Board; int i; int j; int rowi; int rowj; int row1_j; Board = 0; i = 0;

next_column: printf( "Next column: Board = %d, i = %d\n", Boar d, i ); if ( i >= n ) { printf( "Solution: %d\n", Board ); goto next_row; } Board = Board * 10; i = i + 1; check_column: rowi = Board % 10; row1_j = Board / 10; printf( "Check column: Board = %d, i = %d, rowi = %d, row1_j = %d\n", Board, i, rowi, row1_j ); if ( rowi >= n ) { previous_column: printf( "Previous column: Board = %d, i = %d\n" , Board, i ); Board = row1_j; i = i - 1; if ( i > 0 ) goto next_row; /* check_column; */ return EXIT_SUCCESS; } j = i; next_j: printf( "Next j: Board = %d, i = %d, j = %d\n", B oard, i, j ); j = j-1; if ( j <= 0 ) { goto next_column; } rowj = row1_j % 10; row1_j = row1_j / 10; if ( abs( rowj - rowi ) == 0 ) { goto next_row; } if ( abs( abs( rowj - rowi ) - i + j ) != 0 ) got o next_j; next_row: printf( "Next row: Board = %d, i = %d\n", Board, i ); Board = Board + 1; goto check_column; }

Nella pagina seguente vengono mostrate le 92 soluzioni per il caso n=8.

�1000.0 b �0.8 B V 475261.3 C ◊ 572631.4 C ◊ 635714.2 C ◊ 647135.2 C ◊ 1357206.4 C ◊ 1460275.3 C ◊ 1463075.2 C ◊ 1506372.4 C ◊ 1572036.4 C ◊ 1625740.3 C ◊ 1647035.2 C ◊ 1750246.3 C ◊ 2064713.5 C ◊ 2417063.5 C ◊ 2417536.0 C ◊ 2460317.5 C ◊ 2473061.5 C ◊ 2514706.3 C ◊ 2516037.4 C ◊ 2516407.3 C ◊ 2530746.1 C ◊ 2531746.0 C ◊ 2570364.1 C ◊ 2570461.3 C ◊ 2571306.4 C ◊ 2617403.5 C ◊ 2617530.4 C ◊ 2736051.4 C ◊ 3047162.5 C ◊ 3047526.1 C ◊ 3147502.6 C ◊ 3162570.4 C ◊ 3162574.0 C ◊ 3164075.2 C ◊ 3174602.5 C ◊ 3175024.6 C ◊ 3504172.6 C ◊ 3571602.4 C ◊ 3572064.1 C ◊ 3607415.2 C ◊ 3627140.5 C ◊ 3641502.7 C ◊ 3642057.1 C ◊ 3702516.4 C ◊ 3704615.2 C ◊

3742061.5 C ◊ 4035716.2 C ◊ 4073162.5 C ◊ 4075261.3 C ◊ 4135720.6 C ◊ 4136275.0 C ◊ 4150637.2 C ◊ 4170362.5 C ◊ 4205713.6 C ◊ 4206175.3 C ◊ 4273605.1 C ◊ 4602753.1 C ◊ 4603175.2 C ◊ 4613702.5 C ◊ 4615203.7 C ◊ 4615207.3 C ◊ 4630275.1 C ◊ 4730251.6 C ◊ 4730615.2 C ◊ 5041726.3 C ◊ 5160247.3 C ◊ 5160374.2 C ◊ 5206471.3 C ◊ 5207316.4 C ◊ 5207413.6 C ◊ 5246031.7 C ◊ 5247031.6 C ◊ 5261370.4 C ◊ 5261740.3 C ◊ 5263071.4 C ◊ 5304716.2 C ◊ 5317460.2 C ◊ 5360241.7 C ◊ 5360714.2 C ◊ 5713064.2 C ◊ 6027531.4 C ◊ 6130742.5 C ◊ 6152037.4 C ◊ 6205741.3 C ◊ 6271405.3 C ◊ 6314702.5 C ◊ 6317502.4 C ◊ 6420571.3 C ◊ 7130642.5 C ◊ 7142063.5 C ◊ 7205146.3 C ◊ 7302516.4 C ◊

Le prime quattro soluzioni sono da intendersi con uno "0" iniziale; si noti che colonne sono numerate da 0 a 7 e non da 1 a 8.

___________________________________________________________________ 139 “Angela Game” – the original!

Questo programma è il gioco “Angela Game” originale (e quindi diverso dal mio – vedi #130 – che è stato tradotto da una versione in Java): il listato è stato tratto da una foto presa nel Laboratorio-museo Tecnologic@mente di Ivrea, quando i nostri amici danesi di www.datamuseum.dk sono andati per far aggiustare definitivamente la loro P101.

Ecco le istruzioni originali:

ANGELA GAME

Il programma del gioco è stato realizzato negli Stati Uniti in occasione del lancio della Programma 101 al BEMA show di New York del 1965. Benché di contenuto scherzoso non era un programma banale né in termini di gioco perche non è facile vincere, né in termini di implementazione in quanto saturava completamente la memoria disponibile della macchina. Non è stato facile, a suo tempo, realizzarlo in 120 istruzioni e utilizzando solo i 5 registri numerici restanti della macchina per i dati memorizzati. Il programma è stato oggi completamente riscritto e la versione attuale occupa 118 istruzioni. Regole del gioco Si fissa una meta da raggiungere senza superarla: si suggerisce un numero compreso tra 30 e 100. L'avversario della P101 comincia a giocare puntando un valore corrispondente a una faccia del dado: da 1 a 6. La P101 risponde con analoga puntata e si continua a puntare così fino alla fine. Se si desidera che a cominciare sia la P101, basta puntare zero alla prima giocata (è consentito solo all' inizio). Non è ammesso giocare la puntata precedente della controparte, ne il valore corrispondente alla faccia opposta del dado, ad esempio: 1 - 6, 2 - 5, 3 - 4. La macchina segnala se l'avversario bara, ma ovviamente essa non bara. Vince chi raggiunge per primo esattamente la meta, o costringe l'avversario a superarla. Perde chi la supera o rinuncia.

Modalità operative 1) Per cominciare introdurre la meta e premere V 2) Introdurre la puntata e battere S. 3) Attendere la risposta della P101 ed introdurre la puntata successiva. Continuare fino alla conclusione del gioco. 4) In caso di errore ripetere la puntata. 5) In qualsiasi momento per ricominciare tornare al punto 1). Ad ogni ciclo la macchina stampa: A) Puntata del giocatore B) Puntata della P101 C) Totale delle puntate ed ecco la foto:

La lettura del listato è stata un po’ difficoltosa a causa dei riflessi visibili a destra ma, grazie ad un po’ di manipolazione grafica, non è stato così difficile da interpretare. Il risultato finale, come si vede a pagina seguente, è stato ottenuto con l'uso del negativo fotografico.

___________________________________________________________________ 140 “Somma dei numeri da 1 a 10”

Questo programma è un esempio didattico apparso sul libro di Pierluigi D’Odorico "I calcolatori elettronici" del 1967 a pagina 82: la cosa interessante è che viene dato, oltre al listato commentato, anche la codifica in binario delle istruzioni! "V" per partire

Ed ecco l’originale:

___________________________________________________________________ 141 “Radice Cubica”

Questo programma è la codifica dell'algoritmo dell'Ing. Caprara dell'Olivetti per il calcolo della radice cubica (con un metodo iterativo). n "V"

L'algoritmo usato è il seguente:

___________________________________________________________________ 142 "Seno & Coseno"

Routine molto compatta per il calcolo di seno e coseno. angolo (in gradi) "Z" "V" calcola seno angolo (in gradi) "Z" "W" calcola coseno Il risultato si trova in F

___________________________________________________________________ 143: "Fattoriale"

Programma di esempio per il calcolo del fattoriale (tratto dal sito www.curtamania.com) n "V"

___________________________________________________________________ 144: "Media-Varianza & Deviazione standard (peso N-1)-t di Student"

tratto da un articolo in Spagnolo "V" xi "S" yi "S" "Z" per stampare i risultati (media, varianza e deviazione standard); poi "t" S per calcolare gli estremi dell'intervallo di Student.