Est-il possible d'utiliser un logarithmique naturel dans votre code SmartPy?

Commeexpliquépar arvidj,iln'y apas de chiffres depointsflottants dans Michelson (ou SmartPyPy),aucun exp ou logfonction.

Touten travaillant avec desnombresnaturels,vouspouvezmettreen œuvre à lamain quelquesexemples quipeuvent vous suffire ounon. Quelquesexemplesici: https://smartpy.io/dev/index.html?template=Calculator.py , https://smartpy.io/dev/index. HTML? Modèle=WorldCalculator.py

Unexemple completpour vous:

 import smartpy as sp

class Calculator(sp.Contract):
    def __init__(self):
        self.init(value = 0)

    @sp.entry_point
    def test(self, x):
        self.data.value = self.log2(x)

    @sp.global_lambda
    def log2(x):
        result = sp.local('result', 0)
        y = sp.local('y', x)
        sp.while 1 < y.value:
            result.value += 1
            y.value //= 2
        sp.result(result.value)
        
if "templates" not in __name__:
    @sp.add_test(name = "Calculator")
    def test():
        c1 = Calculator()
        scenario = sp.test_scenario()
        scenario += c1
        scenario += c1.test(1000)
        scenario.verify(c1.data.value == 9)
 

éditer. Ajout d'uneimplémentation deprécisionfixe dans SmartPy.

https://smartpy.io/dev/index.html?template=fixe_precision.py

As explained by Arvidj, there are no floating point numbers in Michelson (or SmartPy), no exp or log function.

While working with natural numbers, you can implement by hand some examples which may or may not be enough for you. Some examples here: https://smartpy.io/dev/index.html?template=calculator.py, https://smartpy.io/dev/index.html?template=worldCalculator.py

A complete example for you:

import smartpy as sp

class Calculator(sp.Contract):
    def __init__(self):
        self.init(value = 0)

    @sp.entry_point
    def test(self, x):
        self.data.value = self.log2(x)

    @sp.global_lambda
    def log2(x):
        result = sp.local('result', 0)
        y = sp.local('y', x)
        sp.while 1 < y.value:
            result.value += 1
            y.value //= 2
        sp.result(result.value)
        
if "templates" not in __name__:
    @sp.add_test(name = "Calculator")
    def test():
        c1 = Calculator()
        scenario = sp.test_scenario()
        scenario += c1
        scenario += c1.test(1000)
        scenario.verify(c1.data.value == 9)

EDIT. Adding a fixed precision implementation in SmartPy.

https://smartpy.io/dev/index.html?template=fixed_precision.py

Vous devez lefairemanuellement ... voici une approchepour calcul log(x)en supposant que vous représentez xen tant quefraction

1. trouveentier M àtravers une recherchebinairetelle que 2 ^m & lt;=x & lt;2 ^ (m + 1) (Mpeut êtrenégatif)
2. letm '=m + (1 si| x/2 ^ (m + 1) -1 -1| & lt;| x/2 ^m-1| 0) (lesplusproches dem oum + 1)
3. let x '=x/2 ^m',notez que| X'-1|& lt;1/3et journal (x)=journal (2 ^m 'x')=m 'journal (2) +journal (x')
4. Soit Y=(1-x ')/(1 + x'),note que -1/7 & lt;Y & LT;1/5
5. LOG (X ') ~=- 2 Y - 2 Y ^ 3/3

You have to do it manually... Here's one approach for compute log(x) assuming you are representing x as a fraction

1. find integer m through binary search such that 2^m <= x < 2^(m+1) (m may be negative)
2. let m' = m + (1 if |x/2^(m+1)-1| < |x/2^m-1| else 0) (the closests of m or m+1)
3. let x' = x / 2^m', note that |x'-1| < 1/3 and log(x) = log(2^m' x') = m' log(2) + log(x')
4. let y = (1-x')/(1+x'), note that -1/7 < y < 1/5
5. log(x') ~= - 2 y - 2 y^3 / 3

J'ai un contrat dejournalbinaire qui utilisepeu demultiplicationset peut être ajustépourtouteprécision depointfixe: https://github.com/sophia-gold/michelson/blob/master/log2fix.tz .Jene pensepas que celapuisse être écrit dans SmartPy,carje l'ai vérifié,ilmanque des changements.Enfonction de vosbesoins,vouspouvez utiliser cela avec le changement deméthode debase ou d'Arthur.

I have a contract for binary log that uses few multiplications and can be adjusted for any fixed point precision: https://github.com/Sophia-Gold/michelson/blob/master/log2fix.tz. I don't think it can be written in SmartPy because last I checked it lacks shifts. Depending on your needs you could use this with change of base or Arthur's method.

Iln'y apas d'instruction de cetype dans Michelson,doncprobablement lamême chosepour SmartPy. Deplus,Michelsonn'apas de valeurs depointsflottants. Vouspouvezimplémenter une version dejournalnaturel vous-même utilisant des divisions répétées,toutefois,laprécision subira. Notez également que celapeut être coûteux augaz.

Une optionest d'avoir le contrat deprendre le contrat deprendre leparamètre de la chaîne horstension de l'exposant calculé,puis de vérifier le contrat de vérifier que l'exposantesten effet correct. Au lieu de (enpseudocode):

    def contract(some_parameter):
       exponent = nl(some_parameter)
 

avoir

    def contract(expected_exponent, some_parameter):
       assert e^expected_exponent = some_parameter
 

Maisencore unefois,vous voustransformerez dans la question que l'exponciationn'estpas disponible dans Michelson (mais que vouspourriezmettreen œuvre avec desmultiplications répétées)et non des valeurs depointsflottants.

Nouspouvonspeut-être vous aidermieux si vous donnezplus de contexte à la question que vous souhaitez résoudre?

There is no such instruction in Michelson, so probably the same goes for SmartPy. Furthermore, Michelson does not having floating point values. You could implement some version of natural log yourself using repeated divisions, however, precision will suffer. Also, note that this can be costly in gas.

One option is to have the contract take the contract take in parameter the exponent calculated off-chain, and then have the contract verify that the exponent is indeed correct. Instead of (in pseudocode):

   def contract(some_parameter):
       exponent = nl(some_parameter)

have

   def contract(expected_exponent, some_parameter):
       assert e^expected_exponent = some_parameter

but again, you will turn into the issue that exponentiation is not available in Michelson (but which you could implement with repeated multiplications), and nor are floating points values.

We can perhaps help you better if you give more context to the issue you want to resolve?