Calcolatrice con numeri romani, tipo XX - IX = XI

#*** RomanCalc.py scritta con Pyton ver. 2.7 per windows 64bit
#*** programma testato unicamente su win seven 64bit.
#*** Funzione che trasforma numeri decimali in numeri romani
#*** Questa però presenta un limite numerico massimo che è 3999
#*** Numeri superiori non possono essere convertiti in quanto
#*** la numerazione romana comprende cifre fino alle migliaia simbolo (M)
#*** cifre superiori per poterle sommare, sotrarre, moltiplicarle etc.
#*** necessitano di caratteri non compresi nei 255 codici ASCII
#*** ATTENZIONE: oltre il 3999 il programma da i numeri nel vero senso
#*** della parola, es. digitate 5656 e vi esce XX.
import sys    #*** header di programma.
#*** Funzione di conversione
def ConvertNum(Num):
   dgt = "IVXLCDM"       #*** Costante dei numeri romani.
   x = 0
   t = ""
   while Num > 0:       #*** esegue un ciclo fino a che il numero delle cifre è finito
       dg = Num % 10    #*** trova il resto della divisione num / 10, o meglio è la funzione MOD di python
       Num = int(Num / 10) #*** divide e trasforma Num in un'intero
       #*** Procedura per la conversione in numero romano.
       if dg == 1:
           t = dgt[x:x+1] + t
       elif dg == 2:
           t = dgt[x:x+1] + dgt[x:x+1] + t
       elif dg == 3:
           t = dgt[x:x+1] + dgt[x:x+1] + dgt[x:x+1] + t
       elif dg == 4:
           t = dgt[x:x+2] + t
       elif dg == 5:
           t = dgt[x + 1:x+2] + t
       elif dg == 6:
           t = dgt[x + 1:x+2] + dgt[x:x+1] + t
       elif dg == 7:
           t = dgt[x + 1:x+2] + dgt[x:x+1] + dgt[x:x+1] + t
       elif dg == 8:
           t = dgt[x + 1:x+2] + dgt[x:x+1] + dgt[x:x+1] + dgt[x:x+1] + t
       elif dg == 9:
           t = dgt[x:x+1] + dgt[x + 2:x+3] + t
       x += 2
   return t
# Programma principale, esegue un ciclo infinito richiamando se stesso fino a che non viene
# immesso (0) o si preme invio senza alcun numero. Procedura errori non implementata.
while 1:
   Num = input("Inserire un numero decimale inferiore a 4000 (0) per uscire: ")
   if Num == 0:
       break
   print "numero romano = ",ConvertNum(Num)   # Stampa il numero romano.

#*** RomaToDec.py scritta con Pyton ver. 2.7 per windows 64bit
#*** programma testato unicamente su win seven 64bit.
#*** Funzione che trasforma numeri romani in numeri decimali.
#*********************************************************************
#*** Bla... Bla... Bla!!! come listato conversione decimale a romano.
#*********************************************************************
#*** Questa però presenta un limite numerico massimo che è MMMCMXCIX (3999)
#*** Numeri superiori non possono essere convertiti in quanto
#*** la numerazione romana comprende cifre fino alle migliaia simbolo (M)
#*** cifre superiori per poterle sommare, sotrarre, moltiplicarle etc.
#*** necessitano di caratteri non compresi nei 255 codici ASCII
#*********************************************************************
#*** ATTENZIONE: oltre il MMMCMXCIX (3999) il programma da errore
#*********************************************************************
import sys    #*** header di programma.
#*** Funzione per dichiarare e sostituire i numeri arabi o decimali a quelli romani
def RomToDec(t):
   Y = 0
   #*** Costanti dei numeri romani.
   I = 1
   V = 5
   X = 10
   L = 50
   C = 100
   D = 500
   M = 1000
   #*** Assegnazione dei numeri decimali
   if t == "I":
       Y = I
   elif t == "V":
       Y = V
   elif t == "X":
       Y = X
   elif t == "L":
       Y = L
   elif t == "C":
       Y = C
   elif t == "D":
       Y = D
   elif t == "M":
       Y = M
   #print Y
   return Y
   
#*** Funzione di conversione
def ConvRomToDec(Rom):
   x = 0
   x1 = 1
   t = ""
   dc = 0
   dc1 = 0
   dec = 0
   z = 0
   for z in range(len(Rom)):       #*** esegue un ciclo fino a che il numero delle cifre romane è finito
       #*** Procedura per la conversione in numero decimale.
       #*** Prende ogni carattere o numero romano, e verifica che non sia inferiore al successivo
       #*** con uno shift da sinistra verso destra.
       #*** Se il carattere o 'numero romano' è maggiore del successivo lo somma,
       #*** altrimenti lo sotrae, con segno negativo per suplire la somma precedente.
       #*****************************************************************************************
       #*** Come prima cosa per sapere se un numero romano è inferiore al successivo, trasformo
       #*** i numeri romani in decimali.
       t = Rom[x:x1]
       dc = RomToDec(t)
       t = Rom[x1:x1 + 1]
       dc1 = RomToDec(t)
       if dc >= dc1:      #**** Converte i positivi tipo ( XXVIII ) = 28
           dec += (dc + dc1) - dc1 # lo sottrae per evitare somme doppie incrementali
       elif dc < dc1:     #**** Converte i negativi tipo (MCMXXX) = 1930 o (IV) = 4
           dec +=  (-dc * 2 + dc1) + dc - dc1
       x += 1
       x1 += 1
   return dec
# Programma principale, esegue un ciclo infinito richiamando se stesso fino a che non viene
# immesso (q) o si preme invio senza alcun carattere romano e non. Procedura errori non implementata.
print "Premere e lasciare premuto (Caps Lock) per comodita."
print "ATTENZIONE: non sbagliare ad immettere i numeri romani. Pena errore nella conversione."
print
while 1:
   Rom = raw_input("Inserire un numero romano non superiore a MMMCMXCIX (3999) (q) per uscire: ")
   if Rom == "q" or Rom == "Q":
       print "FINE. Grazie per aver usato RomaToDec.py"
       break
   print
   print "Premere e lasciare premuto (Caps Lock) per comodita."
   print "ATTENZIONE: non sbagliare ad immettere i numeri romani. Pena errore nella conversione."
   print
   print "numero decimale = ",ConvRomToDec(Rom)   # Stampa il numero decimale.

#************* RomanCalc.py ver 1.00 *************
#************ Scritto in Python ver 2.7  *********
#*** Converte numeri decimali in numeri romani e viceversa ***

#*** 14/12/2010 RomanCalc.py is licenced under LGPL. ***
#*** http://www.gnu.org/licenses/lgpl.html ***

#*** I'd be happy to hear if you use this in your software. ***
# Copyright (C) 2010 xyzangelo@gmail.com
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
#
#*** programma testato unicamente su win seven 64bit.
#*** Funzione che trasforma numeri decimali in numeri romani
#*** Questa però presenta un limite numerico massimo che è 3999
#*** Numeri superiori non possono essere convertiti in quanto
#*** la numerazione romana comprende cifre fino alle migliaia simbolo (M)
#*** cifre superiori per poterle sommare, sotrarre, moltiplicarle etc.
#*** necessitano di caratteri non compresi nei 255 codici ASCII
#*** ATTENZIONE: oltre il 3999 il programma da i numeri nel vero senso
#*** della parola, es. digitate 5656 e vi esce XX.
import sys    #*** header di programma.
def ConvertNum(Num):
   dgt = "IVXLCDM"       #*** Costante dei numeri romani.
   x = 0
   t = ""
   while Num > 0:       #*** esegue un ciclo fino a che il numero delle cifre è finito
       dg = Num % 10    #*** trova il resto della divisione num / 10, o meglio è la funzione MOD di python
       Num = int(Num / 10) #*** divide e trasforma Num in un'intero
       #*** Procedura per la conversione in numero romano.
       if dg == 1:
           t = dgt[x:x+1] + t
       elif dg == 2:
           t = dgt[x:x+1] + dgt[x:x+1] + t
       elif dg == 3:
           t = dgt[x:x+1] + dgt[x:x+1] + dgt[x:x+1] + t
       elif dg == 4:
           t = dgt[x:x+2] + t
       elif dg == 5:
           t = dgt[x + 1:x+2] + t
       elif dg == 6:
           t = dgt[x + 1:x+2] + dgt[x:x+1] + t
       elif dg == 7:
           t = dgt[x + 1:x+2] + dgt[x:x+1] + dgt[x:x+1] + t
       elif dg == 8:
           t = dgt[x + 1:x+2] + dgt[x:x+1] + dgt[x:x+1] + dgt[x:x+1] + t
       elif dg == 9:
           t = dgt[x:x+1] + dgt[x + 2:x+3] + t
       x += 2
   return t
#*** Funzione che trasforma numeri romani in numeri decimali.
#*********************************************************************
#*** Bla... Bla... Bla!!! come listato conversione decimale a romano.
#*********************************************************************
#*** Questa però presenta un limite numerico massimo che è MMMCMXCIX (3999)
#*** Numeri superiori non possono essere convertiti in quanto
#*** la numerazione romana comprende cifre fino alle migliaia simbolo (M)
#*** cifre superiori per poterle sommare, sotrarre, moltiplicarle etc.
#*** necessitano di caratteri non compresi nei 255 codici ASCII
#*********************************************************************
#*** ATTENZIONE: oltre il MMMCMXCIX (3999) il programma da errore
#*********************************************************************
#*** Funzione per dichiarare e sostituire i numeri arabi o decimali a quelli romani
def RomToDec(t):
   Y = 0
   #*** Costanti dei numeri romani.
   I = 1
   V = 5
   X = 10
   L = 50
   C = 100
   D = 500
   M = 1000
   #*** Assegnazione dei numeri decimali
   if t == "I":
       Y = I
   elif t == "V":
       Y = V
   elif t == "X":
       Y = X
   elif t == "L":
       Y = L
   elif t == "C":
       Y = C
   elif t == "D":
       Y = D
   elif t == "M":
       Y = M
   return Y
   
#*** Funzione di conversione
def ConvRomToDec(Rom):
   x = 0
   x1 = 1
   t = ""
   dc = 0
   dc1 = 0
   dec = 0
   z = 0
   for z in range(len(Rom)):       #*** esegue un ciclo fino a che il numero delle cifre romane è finito
       #*** Procedura per la conversione in numero decimale.
       #*** Prende ogni carattere o numero romano, e verifica che non sia inferiore al successivo
       #*** con uno shift da sinistra verso destra.
       #*** Se il carattere o 'numero romano' è maggiore del successivo lo somma,
       #*** altrimenti lo sotrae, con segno negativo per suplire la somma precedente.
       #*****************************************************************************************
       #*** Come prima cosa per sapere se un numero romano è inferiore al successivo, trasformo
       #*** i numeri romani in decimali.
       t = Rom[x:x1]
       dc = RomToDec(t)
       t = Rom[x1:x1 + 1]
       dc1 = RomToDec(t)
       if dc >= dc1:      #**** Converte i positivi tipo ( XXVIII ) = 28
           dec += (dc + dc1) - dc1 # lo sottrae per evitare somme doppie incrementali
       elif dc < dc1:     #**** Converte i negativi tipo (MCMXXX) = 1930 o (IV) = 4
           dec +=  (-dc * 2 + dc1) + dc - dc1
       x += 1
       x1 += 1
   return dec
while 1:
   print "Calcolatrice romana... ver 1.00"
   print
   print "1) = Convertitore Decimale Romano..."
   print "2) = Convertitore Romano Decimale..."
   print "3) = Calcolatrice Romana............"
   print "4) = Uscita dal programma..........."
   print
   Qst = input("Sciegliere un numero tra 1 e 4: ")
   if Qst == 1:
       Num = input("Inserire un numero decimale inferiore a 4000: ")
       if Num == 0:
           break
       print "numero romano = ",ConvertNum(Num)   # Stampa il numero romano.
   if Qst == 2:
       print "Premere e lasciare premuto (Caps Lock) per comodita."
       print "ATTENZIONE: non sbagliare ad immettere i numeri romani. Pena errore nella conversione."
       print
       #ERRORE o COSA? Se si seleziona dal menu la calcolatrice, il progr non dovrebbe dopo il calcolo saltare QUI!!! HELP ME PLEASE
           Rom = raw_input("Inserire un numero romano non superiore a MMMCMXCIX (3999): ")
           print "numero decimale = ",ConvRomToDec(Rom)   # Stampa il numero decimale.
   if Qst == 3:
       print
       print "immettere i numeri romani da sommare, sotrarre, moltiplicare,o dividere max(MMMCMXCIX 3999)."
       print "Il primo numero deve essere seguito dall'operatore."
       print "(Es: XXV+ e premere invio quindi Immettere XX e premere invio)"
       print "Risultato = XLV"
       N1 = raw_input("Primo numero Romano -> ")
       N2 = raw_input("Secondo numero Romano -> ")
       if N1 == "" or N2 == "":
           break
       #*** Estrapola dalla stringa il primo numero, l'operatore
       z = 0
       Nx = 0
       Ny = 0
       Risult = 0
       p1 = N1[z:len(N1)-1] #* Estrae il primo numero
       op = N1[len(N1)-1:]  #* Estrae l'operatore
       Nx = ConvRomToDec(p1)
       Ny = ConvRomToDec(N2)
       if op == '+':
           Risult = Nx + Ny
       elif op == '-':
           Risult = Nx - Ny
       elif op == '*':
           Risult = Nx * Ny
       elif op == '/':
           Risult = int(Nx / Ny)
       print "Risultato operazione = ",ConvertNum(Risult)   # Stampa il risultato in numero romano.3
   if Qst == 4:
       print "FINE. Grazie per aver usato CalcRoman.py"
       break
   Rom = raw_input("Inserire un numero romano non superiore a MMMCMXCIX (3999) (q) per uscire: ")
   
   print
   print "Premere e lasciare premuto (Caps Lock) per comodita."
   print "ATTENZIONE: non sbagliare ad immettere i numeri romani. Pena errore nella conversione."
   print
   print "numero decimale = ",ConvRomToDec(Rom)   # Stampa il numero decimale.

#************* RomanCalc.py ver 1.01 *************
#************ Scritto in Python ver 2.7  *********
#*** Calcolatrice e convertitore numeri decimali in numeri romani e viceversa ***

#*** 17/12/2010 RomanCalc.py is licenced under LGPL. ***
#*** http://www.gnu.org/licenses/lgpl.html ***

#*** I'd be happy to hear if you use this in your software. ***
# Copyright (C) 2010 xyzangelo@gmail.com
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
#
# Le funzioni del programma sono illustrate nel primo listato
#
#**************************** MODIFICHE DELLA VER. 1.01 ********************************
# 1) Semplificazione del listato sorgente
# 2) Possibilità di eseguire un'operazione Romana in un'unico input
# 3) Coretto il BUG che richiamava a loop la funzione di conversione Romano Decimale
#****************************************************************************************
#*** ATTENZIONE: oltre il 3999 il programma da i numeri nel vero senso
#*** della parola, es. digitate 5656 e vi esce XX.
import sys    
def SelezUno():
   Num = input("Inserire un numero decimale inferiore a 4000: ")
   print "numero romano = ",ConvertNum(Num)  
def SelezDue():
   print "Premere e lasciare premuto (Caps Lock) per comodita."
   print "ATTENZIONE: non sbagliare ad immettere i numeri romani. Pena errore nella conversione."
   print
   Rom = raw_input("Inserire un numero romano non superiore a MMMCMXCIX (3999): ")
   print "numero decimale = ",ConvRomToDec(Rom)  
def SelezTre():
   print
   print "immettere i numeri romani da sommare, sotrarre, moltiplicare,o dividere max(MMMCMXCIX 3999)."
   print "Immettere l'espressione senza spazi."
   print "(Es: XXV+V e premere invio)"
   print "Risultato = XXX"
   N1 = raw_input("Immettere l'operazione Romana da eseguire -> ")
   #*** Estrapola dalla stringa  primo secondo numero e l'operatore
   z = 0
   Nx = 0
   Ny = 0
   Risult = 0
   for z in range(len(N1)):
       if N1[z:z+1] == '+' or N1[z:z+1] == '-' or N1[z:z+1] == '*' or N1[z:z+1] == '/':
           p1 = N1[:z]     #* Estrae il primo numero
           op = N1[z:z+1]  #* Estrae l'operatore
           N2 = N1[z+1:]   #Estrae il secondo numero
   Nx = ConvRomToDec(p1)
   Ny = ConvRomToDec(N2)
   if op == '+':
       Risult = Nx + Ny
   elif op == '-':
       Risult = Nx - Ny
   elif op == '*':
       Risult = Nx * Ny
   elif op == '/':
       Risult = int(Nx / Ny)
   print
   print "Risultato operazione = ",ConvertNum(Risult)    
def ConvRomToDec(Rom):
   x = 0
   x1 = 1
   t = ""
   dc = 0
   dc1 = 0
   dec = 0
   z = 0
   for z in range(len(Rom)):
       t = Rom[x:x1]
       dc = RomToDec(t)
       t = Rom[x1:x1 + 1]
       dc1 = RomToDec(t)
       if dc >= dc1:      
           dec += (dc + dc1) - dc1
       elif dc < dc1:    
           dec +=  (-dc * 2 + dc1) + dc - dc1
       x += 1
       x1 += 1
   return dec
def ConvertNum(Num):
   dgt = "IVXLCDM"      
   x = 0
   t = ""
   while Num > 0:      
       dg = Num % 10  
       Num = int(Num / 10)
       if dg == 1:
           t = dgt[x:x+1] + t
       elif dg == 2:
           t = dgt[x:x+1] + dgt[x:x+1] + t
       elif dg == 3:
           t = dgt[x:x+1] + dgt[x:x+1] + dgt[x:x+1] + t
       elif dg == 4:
           t = dgt[x:x+2] + t
       elif dg == 5:
           t = dgt[x + 1:x+2] + t
       elif dg == 6:
           t = dgt[x + 1:x+2] + dgt[x:x+1] + t
       elif dg == 7:
           t = dgt[x + 1:x+2] + dgt[x:x+1] + dgt[x:x+1] + t
       elif dg == 8:
           t = dgt[x + 1:x+2] + dgt[x:x+1] + dgt[x:x+1] + dgt[x:x+1] + t
       elif dg == 9:
           t = dgt[x:x+1] + dgt[x + 2:x+3] + t
       x += 2
   return t
def RomToDec(t):
   Y = 0
   I = 1
   V = 5
   X = 10
   L = 50
   C = 100
   D = 500
   M = 1000
   if t == "I":
       Y = I
   elif t == "V":
       Y = V
   elif t == "X":
       Y = X
   elif t == "L":
       Y = L
   elif t == "C":
       Y = C
   elif t == "D":
       Y = D
   elif t == "M":
       Y = M
   return Y
while 1:
   print
   print "Calcolatrice romana... ver 1.01"
   print "-------------------------------"
   print "1) = Convertitore Decimale Romano..."
   print "2) = Convertitore Romano Decimale..."
   print "3) = Calcolatrice Romana............"
   print "4) = Uscita dal programma..........."
   print
   Qst = input("Sciegliere un numero tra 1 e 4: ")
   if Qst == 1:
       SelezUno()
   elif Qst == 2:
       SelezDue()
   elif Qst == 3:
       SelezTre()
   elif Qst == 4:
       print "FINE. Grazie per aver usato CalcRoman.py"
       break

Option Explicit
Dim CRoman  As Boolean ' Valore boleano per determinare se si usano mumeri romai o decimali
Dim Operaz As Boolean ' Valore boleano per determinare se si stà eseuendo un'operazione
Dim Operator As String, Result As Integer
Dim I As String
Dim V As String
Dim X As String
Dim L As String
Dim C As String
Dim D As String
Dim M As String

Function RomDec(q As String) As Integer
Dim Y As Integer
   Y = 0
   I = 1
   V = 5
   X = 10
   L = 50
   C = 100
   D = 500
   M = 1000
   If q = "I" Then
       Y = I
   ElseIf q = "V" Then
       Y = V
   ElseIf q = "X" Then
       Y = X
   ElseIf q = "L" Then
       Y = L
   ElseIf q = "C" Then
       Y = C
   ElseIf q = "D" Then
       Y = D
   ElseIf q = "M" Then
       Y = M
   End If
   RomDec = Y
End Function

Function RomanToDec(ByVal N1 As String) As Integer
'Funzione di conversione da romano a decimale
'Riceve in entrata per valore un nstringa (ByVal N)
'E restituisce una intero, o numero decimale. [ RomanToDec(xxx) ]
Dim X As Integer, Decim As Integer, t As String, dc As Integer, dc1 As Integer, z As Integer

X = 2
t = ""
dc = 0
dc1 = 0
Decim = 0
For z = 1 To (Len(N1))
   t = Mid(N1, z, 1)
   dc = RomDec(t)
       t = Mid(N1, X, 1)
   dc1 = RomDec(t)
       If dc >= dc1 Then
           Decim = Decim + (dc + dc1) - dc1
       ElseIf dc < dc1 Then
           Decim = Decim + (-dc * 2 + dc1) + dc - dc1
       End If
   X = X + 1
Next z
   RomanToDec = Decim
End Function

Private Sub SMSD()
On Error GoTo ERRHANDLER
'Legge e separa i numeri dall'operatore.
Dim r As Integer, NFirst, NSecond, X As Integer, N1 As Integer, N2 As Integer
X = 0: N1 = 0: N2 = 0
For r = 1 To Len(lblVisual.Caption)
If Mid(lblVisual.Caption, r, 1) = "+" Or Mid(lblVisual.Caption, r, 1) = "-" _
Or Mid(lblVisual.Caption, r, 1) = "*" Or Mid(lblVisual.Caption, r, 1) = "/" Then
X = r - 1
Operator = Mid(lblVisual.Caption, r, 1) 'Operatore
End If
Next r
NFirst = Mid(lblVisual.Caption, 1, X)  'Primo numero
NSecond = Mid(lblVisual.Caption, X + 2, Len(lblVisual.Caption)) 'Secondo numero
If CRoman = True Then ' converte romano in decimale
N1 = RomanToDec(NFirst)
N2 = RomanToDec(NSecond)
Else
N1 = Int(NFirst)
N2 = Int(NSecond)
End If
Select Case Operator
Case "+"
   Result = N1 + N2
Case "-"
   Result = N1 - N2
Case "*"
   Result = N1 * N2
Case "/"
   Result = N1 \ N2
End Select
If CRoman = True Then ' converte romano in decimale
lblConv.Caption = "Risultato = " & NumRoman(Result)
Else
lblConv.Caption = "Risultato = " & Result
End If
Exit Sub
ERRHANDLER:
MsgBox ("Errore durante il calcolo..."), vbOKOnly + vbExclamation, "Err."
Call cmdCanc_Click
End Sub

Private Sub cmdCanc_Click()
lblVisual.Caption = Empty
lblConv.Caption = Empty
cmdConvRomDec.Enabled = True
cmdConvDecRom.Enabled = True
Operaz = False
Operator = Empty
End Sub

Private Sub cmdConvDecRom_Click()
FDecimal.Move 120, 840
FRoman.Visible = False
FDecimal.Visible = True
CRoman = False
Call cmdCanc_Click
End Sub

Private Sub cmdConvRomDec_Click()
FRoman.Move 120, 840
FRoman.Visible = True
FDecimal.Visible = False
CRoman = True
Call cmdCanc_Click
End Sub


Private Sub cmdResult_Click()
If Operaz = True Then
Call SMSD 'Chiama la routine che (S)omma, (M)oltiplica, (S)ottrae, (D)ivide.
Exit Sub
End If
If CRoman = False Then     '*** Visualizza la decodifica da decimale a romano
lblConv.Caption = NumRoman(lblVisual.Caption)
ElseIf CRoman = True Then '*** Visualizza la decodifica da romano a decimale
lblConv.Caption = RomanToDec(lblVisual.Caption)
End If
End Sub

Private Sub Form_Load()
FrmMain.Caption = App.Title
lblVisual.Caption = Empty
CRoman = True
End Sub

Private Sub ErrNumOver()
MsgBox ("Numero tropo grande, max(3999)!!!"), vbOKOnly + vbInformation, "Sorry:"
Call cmdCanc_Click
End Sub

Function NumRoman(ByVal N As Integer) As String
'Funzione di conversione da decimale a romano
'Riceve in entrata per valore un num decimale intero (ByVal N)
'E restituisce una stringa, o numero romano. [ NumRoman(xxx) ]
     If N > 3999 Then
     Call ErrNumOver
     Exit Function
     End If
     Const NRomani = "IVXLCDM"    '*** Dichiaro la costante con i numeri romani
     Dim nr As Integer, Resto As Integer, t As String   '*** Variabili locali di funzione
       nr = 1
       t = ""
       Do While N > 0
         Resto = N Mod 10
         N = N \ 10
         Select Case Resto
           Case 1
             t = Mid(NRomani, nr, 1) & t
           Case 2
             t = Mid(NRomani, nr, 1) & Mid(NRomani, nr, 1) & t
           Case 3
             t = Mid(NRomani, nr, 1) & Mid(NRomani, nr, 1) & Mid(NRomani, nr, 1) & t
           Case 4
             t = Mid(NRomani, nr, 2) & t
           Case 5
             t = Mid(NRomani, nr + 1, 1) & t
           Case 6
             t = Mid(NRomani, nr + 1, 1) & Mid(NRomani, nr, 1) & t
           Case 7
             t = Mid(NRomani, nr + 1, 1) & Mid(NRomani, nr, 1) & Mid(NRomani, nr, 1) & t
           Case 8
             t = Mid(NRomani, nr + 1, 1) & Mid(NRomani, nr, 1) & Mid(NRomani, nr, 1) & Mid(NRomani, nr, 1) & t
           Case 9
             t = Mid(NRomani, nr, 1) & Mid(NRomani, nr + 2, 1) & t
         End Select
         nr = nr + 2
       Loop
       NumRoman = t
End Function


Private Sub NumD_Click(Index As Integer)
Select Case Index
Case Index
cmdConvRomDec.Enabled = False
cmdConvDecRom.Enabled = False
lblVisual.Caption = lblVisual.Caption & NumD(Index).Caption
End Select
End Sub

Private Sub NumR_Click(Index As Integer)
Select Case Index
Case Index
cmdConvRomDec.Enabled = False
cmdConvDecRom.Enabled = False
lblVisual.Caption = lblVisual.Caption & NumR(Index).Caption
End Select

End Sub


Private Sub Oper_Click(Index As Integer)
Select Case Index
Case Index
lblVisual.Caption = lblVisual.Caption & Oper(Index).Caption
End Select
Operaz = True
End Sub