Допилил stubs

Улучшил отчёт, добавил скрины

src/main/kotlin/Main.kt

@@ -58,7 +58,7 @@ fun main(args: Array<String>) {
             val result = computeFunc(x, eps)
             data.add(x to result)
         } catch (_: Exception) {
-            // skip discontinuities
+            // скипать точки, где функция не определена
         }
         x += step
     }

src/main/kotlin/function/stubs/CosStub.kt

@@ -1,10 +1,59 @@
 package function.stubs
 
 import function.trigonometric.ICos
+import kotlin.math.PI
+import kotlin.math.abs
 
 class CosStub : ICos {
+    private val table =
+        mapOf(
+            -PI to -1.0,
+            -PI / 2 to 0.0,
+            -1.0 to 0.5403,
+            -0.5 to 0.8776,
+            0.0 to 1.0,
+            0.5 to 0.8776,
+            1.0 to 0.5403,
+            PI / 2 to 0.0,
+            PI to -1.0,
+            3.0 to -0.98999,
+        )
+
     override fun cos(
         x: Double,
         eps: Double,
-    ): Double = 1.0
+    ): Double {
+        var nx = x % (2 * PI)
+        if (nx > PI) nx -= 2 * PI
+        if (nx < -PI) nx += 2 * PI
+
+        var closestX = table.keys.first()
+        var minDiff = abs(nx - closestX)
+        for (kx in table.keys) {
+            val diff = abs(nx - kx)
+            if (diff < minDiff) {
+                minDiff = diff
+                closestX = kx
+            }
+        }
+        if (minDiff < 0.1) return table[closestX]!!
+
+        val sortedKeys = table.keys.sorted()
+        for (i in 0 until sortedKeys.size - 1) {
+            val k1 = sortedKeys[i]
+            val k2 = sortedKeys[i + 1]
+            if (nx in k1..k2) {
+                val y1 = table[k1]!!
+                val y2 = table[k2]!!
+                val t = (nx - k1) / (k2 - k1)
+                return y1 + t * (y2 - y1)
+            }
+        }
+        val k1 = sortedKeys[sortedKeys.size - 2]
+        val k2 = sortedKeys.last()
+        val y1 = table[k1]!!
+        val y2 = table[k2]!!
+        val t = (nx - k1) / (k2 - k1)
+        return y1 + t * (y2 - y1)
+    }
 }

src/main/kotlin/function/stubs/CotStub.kt

@@ -1,10 +1,58 @@
 package function.stubs
 
 import function.trigonometric.ICot
+import kotlin.math.PI
+import kotlin.math.abs
 
 class CotStub : ICot {
+    private val table =
+        mapOf(
+            -PI + 0.1 to -10.0,
+            -PI / 2 to 0.0,
+            -1.0 to -0.6421,
+            -0.5 to -1.8305,
+            0.5 to 1.8305,
+            1.0 to 0.6421,
+            PI / 2 to 0.0,
+            PI - 0.1 to 10.0,
+        )
+
     override fun cot(
         x: Double,
         eps: Double,
-    ): Double = 1.0
+    ): Double {
+        if (abs(x % PI) < 1e-8) throw ArithmeticException("Cot is undefined at x = k*PI")
+        var nx = x % (2 * PI)
+        if (nx > PI) nx -= 2 * PI
+        if (nx < -PI) nx += 2 * PI
+
+        var closestX = table.keys.first()
+        var minDiff = abs(nx - closestX)
+        for (kx in table.keys) {
+            val diff = abs(nx - kx)
+            if (diff < minDiff) {
+                minDiff = diff
+                closestX = kx
+            }
+        }
+        if (minDiff < 0.2) return table[closestX]!!
+
+        val sortedKeys = table.keys.sorted()
+        for (i in 0 until sortedKeys.size - 1) {
+            val k1 = sortedKeys[i]
+            val k2 = sortedKeys[i + 1]
+            if (nx in k1..k2) {
+                val y1 = table[k1]!!
+                val y2 = table[k2]!!
+                val t = (nx - k1) / (k2 - k1)
+                return y1 + t * (y2 - y1)
+            }
+        }
+        val k1 = sortedKeys[sortedKeys.size - 2]
+        val k2 = sortedKeys.last()
+        val y1 = table[k1]!!
+        val y2 = table[k2]!!
+        val t = (nx - k1) / (k2 - k1)
+        return y1 + t * (y2 - y1)
+    }
 }

src/main/kotlin/function/stubs/CscStub.kt

@@ -1,10 +1,58 @@
 package function.stubs
 
 import function.trigonometric.ICsc
+import kotlin.math.PI
+import kotlin.math.abs
 
 class CscStub : ICsc {
+    private val table =
+        mapOf(
+            -PI + 0.1 to -10.0, // около полюса
+            -PI / 2 to -1.0,
+            -1.0 to -1.1884,
+            -0.5 to -2.0858,
+            0.5 to 2.0858,
+            1.0 to 1.1884,
+            PI / 2 to 1.0,
+            PI - 0.1 to 10.0,
+        )
+
     override fun csc(
         x: Double,
         eps: Double,
-    ): Double = 1.0
+    ): Double {
+        if (abs(x % PI) < 1e-8) throw ArithmeticException("Csc is undefined at x = k*PI")
+        var nx = x % (2 * PI)
+        if (nx > PI) nx -= 2 * PI
+        if (nx < -PI) nx += 2 * PI
+
+        var closestX = table.keys.first()
+        var minDiff = abs(nx - closestX)
+        for (kx in table.keys) {
+            val diff = abs(nx - kx)
+            if (diff < minDiff) {
+                minDiff = diff
+                closestX = kx
+            }
+        }
+        if (minDiff < 0.2) return table[closestX]!!
+
+        val sortedKeys = table.keys.sorted()
+        for (i in 0 until sortedKeys.size - 1) {
+            val k1 = sortedKeys[i]
+            val k2 = sortedKeys[i + 1]
+            if (nx in k1..k2) {
+                val y1 = table[k1]!!
+                val y2 = table[k2]!!
+                val t = (nx - k1) / (k2 - k1)
+                return y1 + t * (y2 - y1)
+            }
+        }
+        val k1 = sortedKeys[sortedKeys.size - 2]
+        val k2 = sortedKeys.last()
+        val y1 = table[k1]!!
+        val y2 = table[k2]!!
+        val t = (nx - k1) / (k2 - k1)
+        return y1 + t * (y2 - y1)
+    }
 }

src/main/kotlin/function/stubs/LnStub.kt

@@ -1,10 +1,55 @@
 package function.stubs
 
 import function.base.ILn
+import kotlin.math.E
+import kotlin.math.abs
 
 class LnStub : ILn {
+    private val table =
+        mapOf(
+            0.1 to -2.302585,
+            0.5 to -0.693147,
+            1.0 to 0.0,
+            E to 1.0,
+            2.0 to 0.693147,
+            5.0 to 1.609438,
+            10.0 to 2.302585,
+            20.0 to 2.995732,
+        )
+
     override fun ln(
         x: Double,
         eps: Double,
-    ): Double = 1.0
+    ): Double {
+        if (x <= 0) throw IllegalArgumentException("Ln is undefined for x <= 0")
+        var closestX = table.keys.first()
+        var minDiff = abs(x - closestX)
+        for (kx in table.keys) {
+            val diff = abs(x - kx)
+            if (diff < minDiff) {
+                minDiff = diff
+                closestX = kx
+            }
+        }
+        if (minDiff < 0.05) return table[closestX]!!
+
+        val sortedKeys = table.keys.sorted()
+        for (i in 0 until sortedKeys.size - 1) {
+            val k1 = sortedKeys[i]
+            val k2 = sortedKeys[i + 1]
+            if (x in k1..k2) {
+                val y1 = table[k1]!!
+                val y2 = table[k2]!!
+                val t = (x - k1) / (k2 - k1)
+                return y1 + t * (y2 - y1)
+            }
+        }
+
+        val k1 = sortedKeys[sortedKeys.size - 2]
+        val k2 = sortedKeys.last()
+        val y1 = table[k1]!!
+        val y2 = table[k2]!!
+        val t = (x - k1) / (k2 - k1)
+        return y1 + t * (y2 - y1)
+    }
 }

src/main/kotlin/function/stubs/LogStub.kt

@@ -1,11 +1,58 @@
 package function.stubs
 
 import function.logarithmic.ILog
+import kotlin.math.E
+import kotlin.math.abs
+import kotlin.math.log10
 
 class LogStub : ILog {
+    private val table =
+        mapOf(
+            0.1 to -1.0,
+            0.5 to -0.3010,
+            1.0 to 0.0,
+            E to 0.4343,
+            2.0 to 0.3010,
+            5.0 to 0.6990,
+            10.0 to 1.0,
+            20.0 to 1.3010,
+        )
+
     override fun log(
         base: Double,
         x: Double,
         eps: Double,
-    ): Double = 1.0
+    ): Double {
+        if (base <= 0 || base == 1.0) throw IllegalArgumentException("Log base must be > 0 and != 1")
+        if (x <= 0) throw IllegalArgumentException("Log argument must be > 0")
+        if (abs(base - 10.0) > 1e-5) return log10(x)
+        var closestX = table.keys.first()
+        var minDiff = abs(x - closestX)
+        for (kx in table.keys) {
+            val diff = abs(x - kx)
+            if (diff < minDiff) {
+                minDiff = diff
+                closestX = kx
+            }
+        }
+        if (minDiff < 0.1) return table[closestX]!!
+
+        val sortedKeys = table.keys.sorted()
+        for (i in 0 until sortedKeys.size - 1) {
+            val k1 = sortedKeys[i]
+            val k2 = sortedKeys[i + 1]
+            if (x in k1..k2) {
+                val y1 = table[k1]!!
+                val y2 = table[k2]!!
+                val t = (x - k1) / (k2 - k1)
+                return y1 + t * (y2 - y1)
+            }
+        }
+        val k1 = sortedKeys[sortedKeys.size - 2]
+        val k2 = sortedKeys.last()
+        val y1 = table[k1]!!
+        val y2 = table[k2]!!
+        val t = (x - k1) / (k2 - k1)
+        return y1 + t * (y2 - y1)
+    }
 }

src/main/kotlin/function/stubs/SecStub.kt

@@ -1,10 +1,61 @@
 package function.stubs
 
 import function.trigonometric.ISec
+import kotlin.math.PI
+import kotlin.math.abs
 
 class SecStub : ISec {
+    private val table =
+        mapOf(
+            -PI to -1.0,
+            -PI / 2 + 0.1 to 10.0,
+            -1.0 to 1.8508,
+            -0.5 to 1.1395,
+            0.0 to 1.0,
+            0.5 to 1.1395,
+            1.0 to 1.8508,
+            PI / 2 - 0.1 to 10.0,
+            PI to -1.0,
+        )
+
     override fun sec(
         x: Double,
         eps: Double,
-    ): Double = 1.0
+    ): Double {
+        if (abs((x % (2 * PI)) - PI / 2) < 1e-8 || abs((x % (2 * PI)) + PI / 2) < 1e-8) {
+            throw ArithmeticException("Sec is undefined at x = PI/2 + k*PI")
+        }
+        var nx = x % (2 * PI)
+        if (nx > PI) nx -= 2 * PI
+        if (nx < -PI) nx += 2 * PI
+
+        var closestX = table.keys.first()
+        var minDiff = abs(nx - closestX)
+        for (kx in table.keys) {
+            val diff = abs(nx - kx)
+            if (diff < minDiff) {
+                minDiff = diff
+                closestX = kx
+            }
+        }
+        if (minDiff < 0.2) return table[closestX]!!
+
+        val sortedKeys = table.keys.sorted()
+        for (i in 0 until sortedKeys.size - 1) {
+            val k1 = sortedKeys[i]
+            val k2 = sortedKeys[i + 1]
+            if (nx in k1..k2) {
+                val y1 = table[k1]!!
+                val y2 = table[k2]!!
+                val t = (nx - k1) / (k2 - k1)
+                return y1 + t * (y2 - y1)
+            }
+        }
+        val k1 = sortedKeys[sortedKeys.size - 2]
+        val k2 = sortedKeys.last()
+        val y1 = table[k1]!!
+        val y2 = table[k2]!!
+        val t = (nx - k1) / (k2 - k1)
+        return y1 + t * (y2 - y1)
+    }
 }

src/main/kotlin/function/stubs/SinStub.kt

@@ -1,10 +1,63 @@
 package function.stubs
 
 import function.base.ISin
+import kotlin.math.PI
+import kotlin.math.abs
 
 class SinStub : ISin {
+    private val table =
+        mapOf(
+            -PI to 0.0,
+            -PI / 2 to -1.0,
+            -1.0 to -0.8415,
+            -0.5 to -0.4794,
+            0.0 to 0.0,
+            0.5 to 0.4794,
+            1.0 to 0.8415,
+            PI / 2 to 1.0,
+            PI to 0.0,
+            3.0 to 0.1411,
+        )
+
     override fun sin(
         x: Double,
         eps: Double,
-    ): Double = 1.0
+    ): Double {
+        // Нормализация в [-PI, PI]
+        var nx = x % (2 * PI)
+        if (nx > PI) nx -= 2 * PI
+        if (nx < -PI) nx += 2 * PI
+
+        // ближайшая точка в таблице
+        var closestX = table.keys.first()
+        var minDiff = abs(nx - closestX)
+        for (kx in table.keys) {
+            val diff = abs(nx - kx)
+            if (diff < minDiff) {
+                minDiff = diff
+                closestX = kx
+            }
+        }
+        if (minDiff < 0.1) return table[closestX]!!
+
+        // интерполяция линейно
+        val sortedKeys = table.keys.sorted()
+        for (i in 0 until sortedKeys.size - 1) {
+            val k1 = sortedKeys[i]
+            val k2 = sortedKeys[i + 1]
+            if (nx in k1..k2) {
+                val y1 = table[k1]!!
+                val y2 = table[k2]!!
+                val t = (nx - k1) / (k2 - k1)
+                return y1 + t * (y2 - y1)
+            }
+        }
+        // экстраполяция
+        val k1 = sortedKeys[sortedKeys.size - 2]
+        val k2 = sortedKeys.last()
+        val y1 = table[k1]!!
+        val y2 = table[k2]!!
+        val t = (nx - k1) / (k2 - k1)
+        return y1 + t * (y2 - y1)
+    }
 }