modulo avec un grand modulus en vb

[physiquantique]

Bonjour à tous ,

Suite à mon projet de programmer un logiciel de chiffrement en rsa avec visual basic , j'ai donc programmé avec succès un logiciel qui marche très bien avec des petites clés (j'ai même rajouté une fonction pour crypter paquets par paquets d'octets , sinon la sécurité serait nulle quoique vu la taille ridicule de mes clés )

Je veux donc à présent pouvoir crypter avec des grandes clés et donc des grands modulus ....

Sauf que vb ne permet pas de faire des calcul avec de telles nombres ...
Je dois donc programmer une fonction bigmodulo(byval a as string , byval modulus as string) pour calculer le modulo d'un nombre modulo un très grand nombre sous forme de string .

Auparavant j'ai donc programmer et testé les fonctions suivantes qui servent respectivement à comparer deux nombres (inégalité stricte je crois) et à les soustraire :

 Function biggerthan(ByVal a As String, ByVal b As String) As Boolean
        If Mid(a, 1, 1) = "-" Then
            If Not Mid(b, 1, 1) = "-" Then
                Return False
                Exit Function
            Else

            End If
        ElseIf Mid(b, 1, 1) = "-" Then
            Return True
            Exit Function

        End If
        Dim i As Integer = 0
        While Mid(a, 1, 1) = "0"
            a = Mid(a, 2)

        End While
        While Mid(b, 1, 1) = "0"
            b = Mid(b, 2)

        End While
        If a.Length > b.Length Then
            Return True
            Exit Function

        End If
        If b.Length > a.Length Then
            Return False
            Exit Function
        End If
        i = 1
        Dim superieur = False

        While i <= a.Length
            If CInt(Mid(a, i, 1)) < CInt(Mid(b, i, 1)) Then
                superieur = False Or superieur
            Else
                superieur = True Or superieur

            End If
            i = i + 1

        End While

        Return superieur





    End Function
    Function bigsoustraction(ByVal m As String, ByVal n As String) As String
        Dim bigger As Boolean = True

        Dim i As Integer = 1

        Dim a As String = m
        Dim b As String = n
        While Mid(a, 1, 1) = "0"
            a = Mid(a, 2)

        End While
        While Mid(b, 1, 1) = "0"
            b = Mid(b, 2)

        End While
     
        If biggerthan(a, b) = True Then

            bigger = True

            a = m
            b = n
        Else
            bigger = False

            a = n
            b = m

        End If
        While Mid(a, 1, 1) = "0"
            a = Mid(a, 2)

        End While
        While Mid(b, 1, 1) = "0"
            b = Mid(b, 2)

        End While

        Dim lena = a.Length
        Dim lenb = b.Length

        'm-n
        Dim result(lena) As Integer
        Dim n1 As Integer
        Dim n2 As Integer
        Dim retenue As Integer = 0
        Dim jeretiens As Boolean = False

        While i <= lena
            
            n1 = CInt(Mid(a, lena - i + 1, 1))
            If i > lenb Then
                n2 = 0
            Else
                n2 = CInt(Mid(b, lenb - i + 1, 1))

            End If
            If jeretiens = False Then
                If n1 < n2 Then
                    result(i) = 10 + n1 - n2
                    jeretiens = True
                    retenue = 1

                Else
                    result(i) = n1 - n2
                    jeretiens = False
                    retenue = 0

                End If
            Else
                n2 = n2 + 1

                If n1 < n2 Then
                    result(i) = 10 + n1 - n2
                    jeretiens = True
                    retenue = 1

                Else
                    result(i) = n1 - n2
                    jeretiens = False
                    retenue = 0
                End If
            End If
            i = i + 1
        End While

        Dim soustraction As String
        i = 0
        soustraction = ""

        While i < lena
            soustraction = soustraction & CStr(result(lena - i))
            i = i + 1
        End While

        If bigger = True Then

            Return soustraction

        Else


            soustraction = "-" & soustraction
            Return soustraction

        End If



    End Function

puis je voudrais programmer la fonction modulo sous la forme suivante :
dim expos = "1"
dim scale ="10"

Tant que biigerthan(bigsoustraction(a,b igproduit(modulus,expos)),modu lus) = true ' soit tant que a-expos*modulus >modulus vrai

expos = bigproduit(expos,scale)

Fin

a = bigsoustraction(a,bigproduit(m odulus,expos))

Tant que bigerthan(a,modulus)

a = bigsoustraction(a,modulus)
FIn

Return a

Sauf que ca marche pas vraiment au vu les résultats . Pourtant , étant donné que j'ai testé les fonctions préliminaires avec succès enfin je crois ... et que la dernière fonction n'utilise que des combinaisons linéaires de a et modulus ... Elle devrait me retourner un résultat au moins de la meme classe que a mod modulus ... Mais ce n'est pas le cas

Je sais pas d'où cela vient ca me rend fou !!!!

Auriez vous une idée ou bien un code permettant de calculer modulo un très grand nombre (chaine de caractère)
qui soit efficace ?

Si c'est le cas merci beaucoup

Merci d'avance .
Bonne journée .
-----

[Optimix]

Sauf que vb ne permet pas de faire des calcul avec de telles nombres ...
Je dois donc programmer une fonction bigmodulo(byval a as string , byval modulus as string) pour calculer le modulo d'un nombre modulo un très grand nombre sous forme de string .

Ce sont les types de variables qui ne le permettent pas. VB, lui le permet.

Pour tester ce code, on met un bouton sur une feuille et on colle dedans les instructions suivantes.
Un peu trop de Goto à mon goût (ancienne programmation séquentielle ?), mais il a la vertu de fonctionner.

Option Explicit
'******************************************************************
' Extra Long Integer Mathematics
'
' Programmer: Eric L. Truitte
' Contact Info: etruitte@programmer.net
' Date Created: April 3, 2003
' Purpose:
'          Functions to handle mathmatics too large for
'          conventional variables and operations.
'
' Copyright notice:
'          This code is subject to the GNU General Public License.
'          If you make changes, add a Revision note.
'          This code is Open Source and should remain so.
'
'******************************************************************
' Revision Date: April 5, 2003
' Programmer: Eric L. Truitte
' Details:
'          Addition and Multiplication tested and finallized
'          Update comments
'
' Revision Date: February 19, 2005
' Programmer: Eric L. Truitte
' Details:
'          Finallized Subtraction and Division
'          Updated comments
'
'******************************************************************
'Notes:
'
'THERE IS CURRENTLY VERY LITTLE FAULT TOLERANCE IN THE FUNCTIONS
'entering a non-numeric character will cause errors.  If you intend to use these,
'make sure what you pass in is just a string of integers.
'
'To do list:
'  Decimals
'  Negatives
'  Multi-string length numbers
'
'What is the largest number that can be handled at this point?
'          A String can hold roughly the largest size of a Long value in characters.
'          That is the number of potential digits you can have in a number.
'
'I will be working on a decimal handling, possitive/negative, and arrays of strings
'containing segments of an Extra Long Integer.  I hope if you have need of such
'capacity of numbers that you have a system that can adequitely handle both
'system overhead and processor side-effects from overclocking for an extended
'period of time.
'
'******************************************************************
Public STOPNOW As Boolean 'This is a sentinel variable used in the demo form

' IntAddition ****************************************************************************
Public Function IntAddition(ByVal FirstNum As String, ByVal SecondNum As String) As String
    Dim a As Long, DifLen As Long, TempStr As String, TempNum As Integer
    Dim Num1 As String, Num2 As String, TempNum1 As Integer, TempNum2 As Integer
    Dim CarryOver As Integer, LeftOvers As Long
    'Setup the numbers so that they are easier to handle.
    'I originally had about 10 nested if statements that this block
    'of code simplifies Dramatically.
    If Len(FirstNum) >= Len(SecondNum) Then
        Num1 = FirstNum
        Num2 = SecondNum
    Else
        Num2 = FirstNum
        Num1 = SecondNum
    End If
 
    'Just setup some of the variables that need an initial value
    DifLen = Len(Num1) - Len(Num2)
    CarryOver = 0
    LeftOvers = DifLen
 
    'Ok, now for the real math.  Looping from the end of the numbers
    'just like our preschool teachers taught us, we add numbers that
    'line up in the 'places' (I.E. ones, tens, hundreds, thousands, etc)
    For a = Len(Num2) To 1 Step -1
        TempNum1 = Int(Mid(Num1, a + DifLen, 1))
        TempNum2 = Int(Mid(Num2, a, 1))
        TempNum = TempNum1 + TempNum2 + CarryOver
        CarryOver = TempNum \ 10
        TempStr = (TempNum - (CarryOver * 10)) & TempStr
        DoEvents
        If STOPNOW = True Then GoTo StopAdd
    Next a
 
    'What do we do if there is a 1 or a 2 that carries over outside the
    'numbers that line up in the places, well, we do the following block of
    'code.  The do loop is used incase we get a situation like this:
    '
    '    199999  When you add 1 to a set of nines it continues to
    '    _+___1  Carry over until it hits the first digit
    '    200000
    Do Until CarryOver = 0 Or LeftOvers = 0
        TempNum = Int(Mid(Num1, LeftOvers, 1)) + CarryOver
        CarryOver = TempNum \ 10
        TempStr = (TempNum - (CarryOver * 10)) & TempStr
        LeftOvers = LeftOvers - 1
    Loop
 
    'Since there are two possible ways of exiting the Loop above, we need
    'to test and apply the other variable and its associated values in the following
    'two if statements.
    'Handle a possible carryover that will drop off the front end creating a new place.
    If CarryOver > 0 Then TempStr = CarryOver & TempStr
    'add any of the numbers that are remaining on the left side of the longer string
    If LeftOvers > 0 Then TempStr = Left(Num1, LeftOvers) & TempStr
    'and return the value
StopAdd:
    IntAddition = TrimZeros(TempStr)
End Function

' IntMultiply ****************************************************************************
Public Function IntMultiply(ByVal FirstNum As String, ByVal SecondNum As String) As String
    Dim ZeroStr As String
    Dim a As Long, b As Long, Multiplier1 As Integer, Multiplier2 As Integer
    Dim Num As Integer, CarryOver As Integer, TempStr As String, TallyStr As String
    'THIS FUNCTION IS COMPLETE AND WORKS
    'This function can handle two extra longs. It cycles through
    'the firstnum one digit at a time from secondnum.
    'this function works on the distrubution Principle of Multiplication:
    ' 9999 * 222 = (9999 * 2) + (9999 * 20) + (9999 * 200)
    '
    'The zero's are concatinated on after the multiplication takes place.
    '
    'This function is dependent on the IntAddition function above.
    For a = Len(FirstNum) To 1 Step -1
        'setup variables for this loop of multiplication
        TempStr = ""
        CarryOver = 0
        Multiplier1 = Mid(FirstNum, a, 1)
     
        'Multiply one digit at a time from right to left
        For b = Len(SecondNum) To 1 Step -1
            Multiplier2 = Mid(SecondNum, b, 1)
            Num = (Multiplier1 * Multiplier2) + CarryOver
            CarryOver = Num \ 10
            TempStr = (Num - (CarryOver * 10)) & TempStr
        Next b
       
        'Check to see if the multiplication added a new digit
        If CarryOver > 0 Then TempStr = CarryOver & TempStr
     
        'Add the zeros
        TempStr = TempStr & ZeroStr
        TallyStr = IntAddition(TempStr, TallyStr)
        ZeroStr = ZeroStr & "0"
        DoEvents
     
        'sentinel
        If STOPNOW = True Then GoTo StopMultiply
    Next a
 
StopMultiply:
    IntMultiply = TrimZeros(TallyStr)
End Function

' TrimZeros ********************************************
Public Function TrimZeros(ByVal Num As String) As String
    Dim a As Long, TempStr As String
    For a = 1 To Len(Num)
        If Mid(Num, a, 1) <> 0 Then GoTo YuckFu
    Next a
    TrimZeros = "0"
    Exit Function
    
YuckFu:
    TrimZeros = Mid(Num, a, Len(Num) - a + 1)
End Function

' IntSubstract ***************************************************************************
Public Function IntSubtract(ByVal FirstNum As String, ByVal SecondNum As String) As String
    '***
    'DO NOT change the integers to bytes, there are negative values in this function
    '***
    Dim Num1 As String, Num2 As String, a As Long, Neg As Boolean, DifLen As Long
    Dim TempStr As String, TempNum1 As Integer, TempNum2 As Integer
    Dim TempNum As Integer, Barrow As Byte
    'This function operates on a theory known as Two-Compliment.
    'If you want to know more, look for it at www.mathforum.com
    'This function works great now
    'This block of code arranges the numbers into the Num1 and Num2 based on
    'which number is larger.  This prevents a great number of errors if the numbers
    'dont line up, or if the larger number is taken from the smaller number.
    If Len(FirstNum) > Len(SecondNum) Then
        Num1 = FirstNum
        Num2 = SecondNum
        Neg = False
    ElseIf Len(FirstNum) < Len(SecondNum) Then
        Num1 = SecondNum
        Num2 = FirstNum
        Neg = True
    Else
        'In the case that the strings are of equal length we have this pretty little
        'set of code to find which number has the first larger digit.
        For a = 1 To Len(FirstNum)
            If Int(Mid(FirstNum, a, 1)) > Int(Mid(SecondNum, a, 1)) Then
                Num1 = FirstNum
                Num2 = SecondNum
                Neg = False
                GoTo ContinSubtraction
            ElseIf Int(Mid(FirstNum, a, 1)) < Int(Mid(SecondNum, a, 1)) Then
                Num1 = SecondNum
                Num2 = FirstNum
                Neg = True
                GoTo ContinSubtraction
            End If
            DoEvents
       
            'sentinel
            If STOPNOW = True Then GoTo ExitFunction
        Next a
     
        'In the case that no larger digit is found, then guess what, its a perfect
        'subtraction, so we don't need to do the function, just assign a 0 outside the end.
        GoTo ExitFunction
    End If
 
ContinSubtraction:
    'If we have a difference in length then ajust with 0's that will not affect the calculations.
    'This allows us to get all the digits into the final out number.
    DifLen = Len(Num1) - Len(Num2)
     Num2 = String(DifLen, "0") & Num2
    Barrow = 0
    'lets do some math
    For a = Len(Num2) To 1 Step -1
        'Pick out the individual digit from each number
        TempNum1 = Int(Mid(Num1, a, 1)) - Barrow
        TempNum2 = Int(Mid(Num2, a, 1))
        Barrow = 0
       
        'Perform single digit subraction using the Two Compliment theory
        If TempNum1 >= TempNum2 Then
            TempNum = TempNum1 - TempNum2
        ElseIf TempNum1 < TempNum2 Then
            TempNum = (TempNum1 + 10) - TempNum2
            Barrow = 1
        End If
     
        'Assign new digit to the final string.
        TempStr = CStr(TempNum) & TempStr
        DoEvents
     
        'sentinel
        If STOPNOW = True Then GoTo ExitFunction
    Next a
    'now, since we are subtracting, we need to determine if the number being returned is a negative.
    'Just to note, the Trim is to remove unneccsary zero's at the head(left) of the return number.
    If Neg = True Then
        IntSubtract = "-" & TrimZeros(Trim(TempStr))
    Else
        IntSubtract = TrimZeros(Trim(TempStr))
    End If
Exit Function

ExitFunction:
    IntSubtract = 0
End Function

' IntDevide ****************************************************************************
Public Function IntDivide(ByVal FirstNum As String, ByVal SecondNum As String) As String
    'Before we even alocate memory for variables, test for some very important error values
    If Len(FirstNum) < Len(SecondNum) Or InStr(1, IntSubtract(FirstNum, SecondNum), "-") > 0 Then
        MsgBox "Fault: Extra Long Division does not support dividing a shorter number by a longer number, as this requires decimals which are not currently handled."
    ElseIf TrimZeros(SecondNum) = "" Then
        MsgBox "Fault: Cannot divide by Zero."
    ElseIf TrimZeros(SecondNum) = "" Then
        GoTo EndFunc
    Else
        GoTo continDivide
    End If
    GoTo ExitDivide
    'After passing the error checking, lets get started with some division
    
continDivide:
    Dim Num1 As String, DivTotal As String, DivMult As String
    Dim DifLen As Long, DivSub As String, TempNum As String
    'Initiallize values
    Num1 = FirstNum
    DivTotal = "0"
    DifLen = (Len(Num1) - Len(SecondNum))
    DivMult = String(DifLen, "0")
    DivSub = SecondNum & DivMult
 
    'Lets do some division
    Do Until (Len(Num1) < Len(SecondNum) Or Num1 = "0" Or (InStr(1, IntSubtract(Num1, SecondNum), "-") > 0 And DivMult = "")) Or STOPNOW = True
        'The way this division works is it subtracts values from the divided number
        'until no more can be subtracted.  This sets up a the largest possible number
        'that can be subtracted from the number so that you remove larger chucks of
        'Numbers at a time and waste less CPU Cycles doing it.
        If DifLen >= 0 Then DivMult = String(DifLen, "0")
        DivSub = SecondNum & DivMult
     
        If InStr(1, IntSubtract(Num1, DivSub), "-") > 0 Then
            If DifLen > 0 Then
                DivMult = String(DifLen - 1, "0")
                DivSub = SecondNum & DivMult
            Else
                Exit Do
            End If
        End If
     
        'Perform the accually math.  DivTotal adds up how many times the original
        'number has been subtracted from the divided number. Num1 is the working
        'number.
        DivTotal = IntAddition(DivTotal, "1" & DivMult)
        Num1 = IntSubtract(Num1, DivSub)
        DifLen = Len(Num1) - Len(SecondNum)
        DoEvents
     
        'sentinel
        If STOPNOW = True Then GoTo ExitDivide
    Loop
 
    'Since there are no decimals, we return return the devide results with a remainder.
    IntDivide = DivTotal & "r" & Num1
    ' Si on ne veut que le modulo
    IntDivide = Num1
 
EndFunc:
    Exit Function
ExitDivide:
    IntDivide = "NaN"
End Function

Private Sub Command1_Click()
    Dim a As String
    Dim b As String
    Dim c As String

    a = "456884526398"
    b = "13456124896"
    c = IntDivide(a, b)
    MsgBox a & " Mod " & b & " = " & c
    End
End Sub

[physiquantique]

Merci beaucoup pour ce code ...
En fait je viens de reregarder mon code , il n'yavait qu'une erreur : la fonction biggerthan était mal programmée ...

En fait je pensais qu'elle partait du chiffre à droite mais elle part du chiffre à gauche.
Après modification la fonction bigmodulo marche sur des chiffres raisonnables , au delà je ne sais pas vu que je n'ai pas d'autre moyen de calcul ...
45454545644 mod 7567 me donne bien 396
etc...
de toute façon comme bigsoustraction à l'air de fonctionner correctement et que je fais des opérations qui ne change pas la classe du première argument modulo le deuxième ... Je pense que cette fonction donne toujours le bon résultat ...

[physiquantique]

En fait c'est pas le modulo qui me pose problème , mais dans mon programme de chiffrement rsa , lorsque j'utilise une clé de grande taille , je ne sais pas pourquoi mais une des variables qui enregistre cette clé écrit la clé avec écriture scientifique , et elle sont convertit en string telles qu'elles "7,6253... E+16" ...

J'ai essayer de forcer à écrire en écriture normale avec format(val(variable),"00000000 00000000000000000...")
Mais je dois pas le faire au bon endroit ... Je cherche encore un peu ... j ' éspère que ca va venir parceque je commence à saturer ...

Merci en tous cas .
Et bonne journée

[A voir en vidéo sur Futura]

[Optimix]

Alors, si tu arrives à programmer la division d'un nombre dépassant la capacité d'une variable Long (VB) par un nombre dépassant la capacité d'une variable Long, ton pb est réglé.

[physiquantique]

bah en fait j'ai programmé cette suite de fonction qui prennent tous des nombres représentés en string (donc taille illimitée entre guillemets) ...
C'est étonnant parceque quand je les teste avec des nombres de tailles raisonnable , et que je compare le résultat avec la calculatrice windows ou sur internet , les résultats sont identiques .
Par contre avec des grands nombres , je crois que les résultats sont faux , je trouve ça vraiment bizzarre ...

Vu le code de la fonction modulo , je vois pas comment je pourrais trouver un résultat faux , à moins que bigsoustraction soit mal écrit (même si pour moi il n'y a pas d'erreur ...) :

Function biggerthan(ByVal a As String, ByVal b As String) As Boolean
        If Mid(a, 1, 1) = "-" Then
            If Not Mid(b, 1, 1) = "-" Then
                Return False
                Exit Function
            Else

            End If
        ElseIf Mid(b, 1, 1) = "-" Then
            Return True
            Exit Function

        End If
        Dim i As Integer = 0
        While Mid(a, 1, 1) = "0"
            a = Mid(a, 2)

        End While
        While Mid(b, 1, 1) = "0"
            b = Mid(b, 2)

        End While
        If a.Length > b.Length Then
            Return True
            Exit Function

        End If
        If b.Length > a.Length Then
            Return False
            Exit Function
        End If
        i = a.Length
        Dim superieur = False

        While i >= 1

            If CInt(Mid(a, i, 1)) < CInt(Mid(b, i, 1)) Then
                superieur = False


            Else
                superieur = True Or superieur


            End If
            i = i - 1

        End While

        Return superieur





    End Function
    Function bigsoustraction(ByVal m As String, ByVal n As String) As String
        Dim bigger As Boolean = True

        Dim i As Integer = 1

        Dim a As String = m
        Dim b As String = n
        While Mid(a, 1, 1) = "0"
            a = Mid(a, 2)

        End While
        While Mid(b, 1, 1) = "0"
            b = Mid(b, 2)

        End While
     
        If biggerthan(a, b) = True Then

            bigger = True

            a = m
            b = n
        Else
            bigger = False

            a = n
            b = m

        End If
        While Mid(a, 1, 1) = "0"
            a = Mid(a, 2)

        End While
        While Mid(b, 1, 1) = "0"
            b = Mid(b, 2)

        End While

        Dim lena = a.Length
        Dim lenb = b.Length

        'm-n
        Dim result(lena) As Integer
        Dim n1 As Integer
        Dim n2 As Integer
        Dim retenue As Integer = 0
        Dim jeretiens As Boolean = False

        While i <= lena
            
            n1 = CInt(Mid(a, lena - i + 1, 1))
            If i > lenb Then
                n2 = 0
            Else
                n2 = CInt(Mid(b, lenb - i + 1, 1))

            End If
            If jeretiens = False Then
                If n1 < n2 Then
                    result(i) = 10 + n1 - n2
                    jeretiens = True
                    retenue = 1

                Else
                    result(i) = n1 - n2
                    jeretiens = False
                    retenue = 0

                End If
            Else
                n2 = n2 + 1

                If n1 < n2 Then
                    result(i) = 10 + n1 - n2
                    jeretiens = True
                    retenue = 1

                Else
                    result(i) = n1 - n2
                    jeretiens = False
                    retenue = 0
                End If
            End If
            i = i + 1
        End While

        Dim soustraction As String
        i = 0
        soustraction = ""

        While i < lena
            soustraction = soustraction & CStr(result(lena - i))
            i = i + 1
        End While

        If bigger = True Then

            Return soustraction

        Else


            soustraction = "-" & soustraction
            Return soustraction

        End If



    End Function
  
    Function bigaddition(ByVal m As String, ByVal n As String) As String

        Dim i As Integer = 0
        Dim a As String
        Dim b As String

        Dim result As String = ""
        Dim n1, n2 As Double





        Dim retenue = 0
        Dim add As Integer



        If m.Length > n.Length Then
            a = m
            b = n
        Else
            a = n
            b = m

        End If

        Dim lena = a.Length
        Dim lenb = b.Length
        While i < lena
            n1 = Val(Mid(a, lena - i, 1))

            If i < lenb Then
                n2 = Val(Mid(b, lenb - i, 1))
            Else
                n2 = 0
            End If
            add = retenue + CInt(n1) + CInt(n2)
            result = CStr(add Mod 10) & result
            If add > 9 Then
                retenue = 1
            Else
                retenue = 0
            End If
            i = i + 1
        End While
        If add > 9 Then
            result = "1" & result

        End If
        Return result

    End Function
  

    Function multichifrre(ByVal nombre As String, ByVal chiffre As Integer) As String

        Dim nombre2 = CStr(nombre)


        Dim nombretemp As Double

        Dim result As String = ""



        Dim retenue As Double = 0


        Dim mult As Double
        Dim multstr As String



        Dim len = nombre2.Length

        Dim i As Integer = 0
        While i < len
            len = nombre2.Length
            nombretemp = Val(Mid(nombre2, len - i, 1))
            mult = nombretemp * chiffre + retenue
            multstr = CStr(mult)

            result = Mid(multstr, multstr.Length) & result
            retenue = (mult - (mult Mod 10)) / 10



            i = i + 1


        End While



        If retenue <> 0 Then
            result = retenue & result
        End If


        Return result



    End Function
    Function bigproduit(ByVal a As String, ByVal b As String, Optional ByVal modulus As Double = 0) As String


        Dim i = 0
        Dim btemp As Integer




        Dim result As String()
        Dim bstr As String = CStr(b)
        Dim lenb = bstr.Length
        Dim resultat As String = ""


        Dim j = 0



        While i < lenb
            btemp = CInt(Mid(bstr, lenb - i, 1))
            ReDim result(i)
            result(i) = multichifrre(a, btemp)
            For j = 1 To i
                result(i) = result(i) & "0"
            Next

            resultat = bigaddition(resultat, result(i))



            i = i + 1
        End While
        If modulus = 0 Then


            Return resultat
        Else
            Return CStr(CDbl(resultat) Mod modulus)

        End If




    End Function



    Function binaire(ByVal p As Double) As Double()

        'ne pas toucher/!\


        Dim pprime As Double()
        Dim k As Integer = 0
        Dim q As Double = p
        While q > 0
            ReDim Preserve pprime(k)
            pprime(k) = q Mod 2
            q = (CDbl(q) - CDbl(q) Mod 2) / 2
            k = k + 1

        End While

        Return pprime


    End Function
    Function puimod(ByVal s As Double, ByVal prime As Double(), ByVal n As Double) As Double


        Dim l As Integer = 0


        Dim temp As Double = s Mod n
        Dim k = prime.Length


        Dim t As Double = 1




        While l < k


            If prime(l) = 1 Then

                t = t Mod n

                t = CDbl(bigproduit(t.ToString, temp.ToString, n))




            End If
            temp = CDbl(bigproduit(temp.ToString, temp.ToString, n))

            l = l + 1
        End While
        Return CDbl(t)
    End Function
    Function puissance(ByVal a As String, ByVal b As String) As String
        Dim i As Double = 0
        Dim result = "1"

        While i < CDbl(b)
            i = i + 1
            result = bigproduit(result, a)

        End While
        Return result

    End Function
    Function puimod(ByVal a As String, ByVal exposantbinaire As Double(), ByVal modulus As Double) As String
        Dim exposant As Double
        Dim i As Integer = 0
        Dim len = exposantbinaire.GetUpperBound(0)
        Dim result As String = "1"
        Dim temp As String = a
        Dim resultmod As Double


        Dim tempmod As Double

        While i <= len
            exposant = exposantbinaire(i)


            If exposant = 1 Then
                result = CStr(CDbl(bigproduit(result, temp)) Mod modulus)


            End If

            temp = CStr(CDbl(bigproduit(temp, temp)) Mod modulus)



            i = i + 1
        End While

        Return result


    End Function
    Function bigmodulo(ByVal firstnum As String, ByVal secondnum As String) As String

        Dim lena As Integer
        Dim lenb As Integer
        lenb = secondnum.Length
        Dim a = firstnum
        Dim b = secondnum
        Dim exposuiv = "10"
        Dim expos = "1"
        Dim scale = "10"
        Dim atemp As String
        Dim lenatemp As Integer


        While Mid(a, 1, 1) = "0"
            a = Mid(a, 2)
        End While
boucle:

        While biggerthan(bigsoustraction(a, bigproduit(exposuiv, b)), b) = True


            'supprime les zéros du début

            While Mid(a, 1, 1) = "0"
                a = Mid(a, 2)
            End While

            exposuiv = bigproduit(expos, scale)

            If biggerthan(bigsoustraction(a, bigproduit(b, exposuiv)), b) Then
                expos = bigproduit(expos, scale)
                a = bigsoustraction(a, bigproduit(b, expos))
                exposuiv = bigproduit(scale, expos)



            Else

                While Mid(a, 1, 1) = "0"
                    a = Mid(a, 2)
                End While

                Exit While


            End If
            'supprime les zéros du début

            While Mid(a, 1, 1) = "0"
                a = Mid(a, 2)
            End While

        End While

        While Mid(a, 1, 1) = "0"
            a = Mid(a, 2)
        End While
        lena = a.Length

        If lena - lenb > 1 Then
            expos = "1"
            exposuiv = "10"
            GoTo boucle
        Else
            While biggerthan(a, b) = True
                a = bigsoustraction(a, b)


            End While
        End If



        Return a
        MsgBox("terminé")
        Button7.Enabled = False


    End Function
    Function bigdivision(ByVal a As String, ByVal b As String) As String
        Dim lena As Integer
        Dim lenb As Integer
        lenb = b.Length


        Dim exposuiv = "10"
        Dim expos = "1"
        Dim scale = "10"
        Dim atemp As String
        Dim lenatemp As Integer

        Dim quotient As String = "0"

        While Mid(a, 1, 1) = "0"
            a = Mid(a, 2)
        End While
boucle:

        While biggerthan(bigsoustraction(a, bigproduit(exposuiv, b)), b) = True


            'supprime les zéros du début

            While Mid(a, 1, 1) = "0"
                a = Mid(a, 2)
            End While

            exposuiv = bigproduit(expos, scale)

            If biggerthan(bigsoustraction(a, bigproduit(b, exposuiv)), b) Then
                expos = bigproduit(expos, scale)
                quotient = bigaddition(expos, quotient)
                a = bigsoustraction(a, bigproduit(b, expos))
                exposuiv = bigproduit(scale, expos)



            Else

                While Mid(a, 1, 1) = "0"
                    a = Mid(a, 2)
                End While

                Exit While


            End If
            'supprime les zéros du début

            While Mid(a, 1, 1) = "0"
                a = Mid(a, 2)
            End While

        End While

        While Mid(a, 1, 1) = "0"
            a = Mid(a, 2)
        End While
        lena = a.Length

        If lena - lenb > 1 Then
            expos = "1"
            exposuiv = "10"
            GoTo boucle
        Else
            While biggerthan(a, b) = True
                a = bigsoustraction(a, b)
                quotient = bigaddition(quotient, "1")


            End While
        End If



        Return quotient

        MsgBox("terminé")
        Button7.Enabled = False
    End Function
    Function binaire(ByVal p As String) As Double()
        While Mid(p, 1, 1) = "0"
            p = Mid(p, 2)
        End While

        Dim q As String = p
        Dim r As String = "0"
        Dim resultat As Double()
        Dim i As Integer = 0

        While biggerthan(q, "0")
            r = bigmodulo(q, "2")
            q = bigdivision(q, "2")
            ReDim Preserve resultat(i)
            resultat(i) = Val(r)


            i = i + 1
        End While
    
        Return resultat


    End Function

Si vous décelez une erreur dans l'une des fonctions , je suis preneur ...
Merci d'avance ...(ps : les fonctions ont des noms explicitant leur fonction).

Bonne journée.

[grosmatou75001]

je n'ai pas d'autre moyen de calcul ...
45454545644 mod 7567 me donne bien 396

Oui c'est bon, il suffit d'un bout de perl p.ex.

use strict;
use warnings;
use bignum;

print 45454545644%7567;

(et encore, le nombre n'est pas si grand que ça, je ne sais même pas si il y a vraiment besoin du bignum mais avec ça fonctionne aussi pour des nombres vraiment grands.)

[physiquantique]

Mais alors pourquoi quand j'utilise ces fonctions pour crypter et décrypter , cela pose problème ?

Soit je passe par le type double et je reconvertit en string là où il faut , et il y a un problème au moment de chiffrer (j'obtients des variables de la forme "00000000 ... E + 000" ) , soit je reste tout le temps en string grace à mes fonctions et alors là c'est le chaos : au moment de déchiffrer , il y a une erreur quand le programme décompose le paquet d'octets décrypté (j'ai créé une fonction paquet qui créer des paquets d'octets à partir du fichier clair , et qui met le résultat sous forme de string "paquet1;paquet2;..." , ensuite je chiffre avec la clé , je stocke sur le fichier destination . Pour déchiffrer j'ai créé une fonction dépaquetage qui recoit un paquet déchiffré et qui le redécompose en octets simples , puis je stocke le résultat au fur et à mesure là où l'utilisateur l'à indiqué).

A force de bidouiller avec les types et les conversions , j'y comprend plus rien ...

Je crois que le mieux c'est que je recommence tout à zéro ...

Bonne journée .

[Optimix]

Pourrait-on avoir un exemple de très grand nombre divisé par un très grand nombre (dépassant donc les capacités d'un proc 64 bits) qui ne fonctionne pas avec le source VB proposé ?

PS : vacances jusqu'au 21/09 à partir de demain matin.

[grosmatou75001]

Désolé, je ne parle pas VB et même si ça n'a pas l'air très difficile à comprendre je n'ai pas le temps de décortiquer ton code. Par contre une chose est sûre: Le type double est pas du tout adapté pour stocker des nombres qui doivent être des entiers, parce qu'il - à cause de la représentation interne - fait une approximation du nombre. C'est aussi pour ça qu'il ne faut jamais faire des comparaisons de type "est égal à" sur des doubles...

Je crois que le mieux c'est que je recommence tout à zéro ...

Prends une version pas trop bricolée du code et rajoute des "write" (enfin l'équivalent VB) pour voir les étapes intermédaires et debugge ainsi.

[grosmatou75001]

En cherchant Visual Basic BigInteger on trouve des trucs qui à première vue ont l'air pas mal, peut-être ce que tu cherches à faire existe déjà (ou alors tu veux tout refaire toi-même pour apprendre)? D'ailleurs ton VB c'est du "vieux VB" avant le .net ou du VB moderne .net ou du VBA sous Excel et Co.?

[bisou10]

VBA avant Office 2007 = VB classique
VBA depuis Office 2007 = VB.NET

Tu peux utiliser System.Numerics.BigInt pour tes calculs http://msdn.microsoft.com/fr-fr/libr...iginteger.aspx

[toothpick-charlie]

sur cette page tu trouveras une liste de bibliothèques qui permettent de faire de l'arithmétique exacte : http://en.wikipedia.org/wiki/Arbitra...ion_arithmetic. Manque de pot il n'y en a pas pour visual basic, c'est l'occasion pour toi de te mettre au C

[physiquantique]

Comme le dit grosmatou je cherche à refaire par moi même ces fonctions plus tôt que de copier une librairie ...
Pour moi (même si je ne connais rien en programmation) , je programme parceque je trouve que c'est une approche constructive des choses ... Alors je vais tout reprendre à zéro en prenant en compte votre indication : le type Double n'est pas approprié ... effectivement je crois que je l'utilise régulièrement en pensant que c'est juste un type qui stocke de très gros entiers ... mais je me trompe .

Merci en tous cas pour vos réponses
bonne journées ...

[physiquantique]

Mais pour la fonction modulo je comprends vraiment pas , vu que j'utilise du string tout le long , pourquoi en dessous d'une certaine taille du modulo , le résultat est bon , et au dessus le résultat est le plus souvent faux ... C'est décourageant ...

[kalahaine]

Ce qui est dit plus haut n'est pas tout à fait vrai:
VBA, VBE = programmation Office, quelle que soit la version.
VB.Net = langage de programmation sur le framework dotnet qui reprend la syntaxe VB mais qui n'a pas grand chose à voir puisqu'on passe d'un programmation procédurale en VBA à de la programmation objet avec .Net.

Concernant ton problème de gestion de nombres importants, je pense en effet que la solution se trouve du côté du bigint.
Tes fonctions ne devraient pas prendre des String en entrée mais des variables "numériques" (int, bingint ou long) selon le type que tu choisis pour tes calculs. VB.Net est un langage avec un typage fort. Tu ne peux procéder à certaines opérations qu'avec les types qui vont bien. L'avantage du type String est que tu en fait ce que tu en veux. Le problème est qu'il n'est pas adapté aux calculs mathématiques. Autant travailler d'emblée avec le type qui va bien.

[Gorzyne]

bon ça fonctionne après niveau performance c'est très limité
si je comprends bien on soustrait le modulus au numérateur autant de fois que nécessaire, sauf qu'en crypto on doit fonctionner avec des nombres avec des centaines de chiffres donc on peut potentiellement soustraire très longtemps si l'ordre de grandeur du numérateur et de modulus est grand...

alors peut être que les doevents ralentissent beaucoup l'execution, même si c'est plus confortable.

pour les sous-fonctions addition, soustraction, multiplication, il y a l'algorithme de trachtenberg qui fait ça très bien je l'ai traduit en vba à la page suivante
https://www.developpez.net/forums/d1.../#post10949125

(j'ai pas comparé avec les algos proposé qu'il faudrait d'abord optimiser)


après le point où je bute ce qui m'a amené sur cette page c'est le fait d'avoir un grand modulus, mais il me paraît nécessaire de passer par une division string et pas soustraction string, ça doit exister

pour info on a cette petite fonction de calcul de modulo qui prend un string au numérateur, et permet d'avoir un modulus long, c'est déjà pas mal, mais bon l'idéal serait d'avoir le modulus string également

Function mod3(S As String, div As Long)
res = 0
For i = 1 To Len(S)
res = (res * 10 + Mid(S, i, 1)) Mod div
Next i
mod3 = res
End Function

[Fustigator]

Bonjour

Vous répondez à une question qui a près de 6 ans.
De plus, j'ai un peu de mal à comprendre l'idée d'utiliser VB qui n'est pas forcément le langage idéal pour ce genre de truc.