Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Kotlin Discussion :

Extraire une variable d'une fonction


Sujet :

Kotlin

  1. #1
    Futur Membre du Club
    Extraire une variable d'une fonction
    Bonjour,

    je suis débutant en Java/Kotlin et je me suis lancé dans la programmation d'une application Android dans le cadre d'un projet de semestre. Je suis bloqué à une étape : je ne sais pas comment extraire une variable (liste) d'une fonction à une autre, voici le code en question :

    Code kotlin :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    internal typealias F = (Double, Double, Double, Double, Double) -> Double
    internal typealias G = (Double, Double, Double, Double) -> Double
    internal typealias Z = (Double, Double, Double) -> Double
     
    class Variables : AppCompatActivity() {
     
     
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.variables)
     
     
        fun main(args: Array<Double>) {
     
     
            fun rungeKutta4(t0: Double, tp: Double, h: Double, f: F, g: G, z: Z) {
     
     
     
                var t = t0
                var x = 0.0
                var xp = 0.0
                var y = 0.0
                var yp = 0.0
                var xna = 0.0
                var xnap = 0.0
     
     
                val p = ((tp-t0)/h).toInt()
     
                val tv = mutableListOf(t)
                val xv = mutableListOf(x)
                val xnav = mutableListOf(xna)
                val yv = mutableListOf(y)
     
     
                for (i in 0..p) {
     
     
                    if (i == p) break
     
     
                    val K1 = f(t,x,xp,y,yp)
                    val L1 = g(x,xp,y,yp)
                    val M1 = z(t,xna,xnap)
                    val Kx = h*xp/2.0 + h*h*K1/8.0
                    val Ky = h*yp/2.0 + h*h*L1/8.0
                    val Kxna = h*xna/2.0 + h*h*M1/8.0
                    val K2 = f(t+h/2.0,x+Kx,xp+h*K1/2.0,y+Ky,yp+h*L1/2.0)
                    val L2 = g(x+Kx,xp+h*K1/2.0,y+Ky,yp+h*L1/2.0)
                    val M2 = z(t+h/2.0,xna+Kxna,xnap+h*M1/2.0)
                    val K3 = f(t+h/2.0,x+Kx,xp+h*K2/2.0,y+Ky,yp+h*L2/2.0)
                    val L3 = g(x+Kx,xp+h*K2/2.0,y+Ky,yp+h*L2/2.0)
                    val M3 = z(t+h/2.0,xna+Kxna,xnap+h*M2/2.0)
                    val Lx = h*xp + h*h*K3/2.0
                    val Ly = h*yp + h*h*L3/2.0
                    val Lxna = h*xnap + h*h*M3/2.0
                    val K4 = f(t+h,x+Lx,xp+h*K3,y+Ly,yp+h*L3)
                    val L4 = g(x+Lx,xp+h*K3,y+Ly,yp+h*L3)
                    val M4 = z(t+h,xna+Lxna,xnap+h*M3)
     
                    x += h*xp + h*h*(K1+K2+K3)/6.0
                    xp += h*(K1+2.0*K2+2.0*K3+K4)/6.0
                    y += h*yp + h*h*(L1+L2+L3)/6.0
                    yp += h*(L1+2.0*L2+2.0*L3+L4)/6.0
                    xna += h*xnap + h*h*(M1+M2+M3)/6.0
                    xnap += h*(M1+2.0*M2+2.0*M3+M4)/6.0
                    t += h
     
                    tv.add(t)
                    xv.add(x)
                    xnav.add(xna)
                    yv.add(y)
     
                }
            }
     
            val F = intent.getStringExtra("F").toDouble()
            val m1 = intent.getStringExtra("m1").toDouble()
            val m2 = intent.getStringExtra("m2").toDouble()
            val k1 = intent.getStringExtra("k1").toDouble()
            val k3 = intent.getStringExtra("k3").toDouble()
            val c1 = intent.getStringExtra("c1").toDouble()
            val c2 = intent.getStringExtra("c2").toDouble()
     
            val f = fun(t: Double, x: Double, xp: Double, y: Double, yp: Double) = (1.0/m1)*(F * cos(sqrt(k1/m1)*t) -k1*x-k3*(x-y)-c1*xp-c2*(xp-yp))
            val g = fun(x: Double, xp: Double, y: Double, yp: Double) = (1.0/m2)*(k3*(x-y)+c2*(xp-yp))
            val z = fun(t: Double, xna: Double, xnap: Double) = (1.0/m1)*(F* cos(sqrt(k1/m1) *t) -k1*xna-c1*xnap)
     
            rungeKutta4(0.0, 10.0, 0.1, f, g, z)
     
        }
    }


    Je voudrais par exemple extraire les variables tv, xv, xnav et yv calculées dans la fonction "rungeKutta4" afin de les utiliser dans un tracé de graphique éventuellement.

    Merci d'avance pour votre aide, pardonnez moi si ce sujet a déjà été traité, j'ai vraiment cherché partout sans trouver de solution à ce problème, pourtant assez simple je l'imagine.

    Samet

  2. #2
    Membre habitué
    Tu devrais peut-être considérer l'utilisation d'une classe rassemblant toutes ces variables dont tu passerais une instance à traiter dans la fonction.
    Ensuite tu pourrais accéder à l'ensemble des valeurs calculées.

  3. #3
    Futur Membre du Club
    Citation Envoyé par Krantz Voir le message
    Tu devrais peut-être considérer l'utilisation d'une classe rassemblant toutes ces variables dont tu passerais une instance à traiter dans la fonction.
    Ensuite tu pourrais accéder à l'ensemble des valeurs calculées.
    Salut Krantz, merci pour ta réponse.

    Je crois que j'ai trouvé comment faire finalement avant-hier, il suffisait de rajouter " :Array<DoubleArray> " à la création de la méthode rungeKutta4 et ensuite ajouter à la fin de la méthode " return arrayOf(tv.toDoubleArray(), xv.toDoubleArray(), xnav.toDoubleArray(), yv.toDoubleArray()) "

    En faisant cela j'ai pu appeler cette méthode dans d'autres méthodes pour utiliser les vecteurs calculés

    Samet