Elementare Funktionen in Kotlin

Question

die Suche nach einer Möglichkeit, elementare Funktionen und deren Derivate bekommen ich es so nähern:

abstract class Fun() { 
    /** 
    * i = 0 -- the function itself, 
    * i = 1, 2, 3, ... -- its successive derivatives 
    */ 
    abstract fun d(i: Int, x: Float): Float 
} 

class Lin(val k: Float) : Fun() { 
    // y = k*x 
    override fun d(i: Int, x: Float, p: Float) = when (i) { 
     0 -> k * x 
     1 -> k 
     else -> 0.0f 
    } 
} 

class Sum(val fun0: Fun, val fun1: Fun) : Fun() { 
    // y = fun0(x) + fun1(x) 
    override fun d(i: Int, x: Float, p: Float) = fun0.d(i, x) + fun1.d(i, x) 
} 

class Example(val fun1: Fun, val fun2: Fun){ 
    var res = fun1.d(0, 5.25f) // fun1 value at 5.25f 
    res = fun1.d(1, 3.29f) // fun1 first derivative at 3.29f 
    val sum = Sum(fun1, fun2) // sum of f1 and f2 
    res = sum(0, 3.78f) // sum value at 3.78f 
    res = sum(1, 5.69f) // sum first derivative at 5.69f 
} 

Gibt es einen idiomatischen Weg, um es in Kotlin zu tun?

Ich habe das Problem wie in Java, also Klassen, die Funktionen enthalten, aufgedeckt. Meine Frage ist, wenn ich das gleiche mit Funktionen tun, geben sie zu einer Klasse auf wie:

class ParametricCurveXYZ(val fun_x: Fun, val fun_y: Fun, val fun_z: Fun) { 

    fun pointToXYZ(s: Float) = VectorXYZ(fun_x.d(0, s), fun_y.d(0, s), fun_z.d(0, s)) 

    fun tangent(s: Float) = VectorXYZ(fun_x.d(1, s), fun_y.d(1, s), fun_z.d(1, s)).normalized() 

} 

Answer 1

Sie lambdas stattdessen Betreiber von regulären Klassen und Überlastung können lambdas kombinieren.

fun lin(k: Float) = { i: Int, x: Float -> 
    when (i) { 
    0 -> k * x 
    1 -> k 
    else -> 0.0f 
    } 
} 

operator fun ((Int, Float) -> Float).plus(that: (Int, Float) -> Float) = 
    { i: Int, x: Float -> this(i, x) + that(i, x) } 

fun doSomething() { 
    val sum = lin(1f) + lin(2f) 
    val res = sum(0, 3.78f) 
}