Compare commits
11
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
c7c333b71a | ||
|
|
e55d9c835a | ||
|
|
83d8c8b71f | ||
|
|
a72991d1b7 | ||
|
|
cd007050a8 | ||
|
|
418b1ae2b6 | ||
|
|
b0fb65a036 | ||
|
|
86e8b2e2bc | ||
|
|
a98fe51983 | ||
|
|
f8d36beae1 | ||
|
|
5ab074ba9e |
No files matched your search
@@ -27,3 +27,4 @@ debug.log
|
||||
/compile_jvm_output.txt
|
||||
/compile_metadata_output.txt
|
||||
test_output*.txt
|
||||
/site/src/version-template/lyng-version.js
|
||||
@@ -221,17 +221,15 @@ All of this is documented in the [language site](https://lynglang.com) and local
|
||||
|
||||
- [x] site with integrated interpreter to give a try
|
||||
- [x] kotlin part public API good docs, integration focused
|
||||
- [ ] type specifications
|
||||
- [x] type specifications
|
||||
- [x] Textmate Bundle
|
||||
- [x] IDEA plugin
|
||||
- [ ] source docs and maybe lyng.md to a standard
|
||||
- [ ] metadata first class access from lyng
|
||||
- [x] source docs and maybe lyng.md to a standard
|
||||
- [x] aggressive optimizations
|
||||
- [ ] compile to JVM bytecode optimization
|
||||
|
||||
## After 1.5 "Ideal scripting"
|
||||
|
||||
Estimated summer 2026
|
||||
* __we are here now ;)__
|
||||
|
||||
- propose your feature!
|
||||
|
||||
@@ -239,8 +237,12 @@ Estimated summer 2026
|
||||
|
||||
@-links are for contacting authors on [project home](https://gitea.sergeych.net/SergeychWorks/lyng): this simplest s to open issue for the person you need to convey any information about this project.
|
||||
|
||||
__Sergey Chernov__ @sergeych: Initial idea and architecture, language concept, design, implementation.
|
||||
<img src="https://www.gravatar.com/avatar/7e3a56ff8a090fc9ffbd1909dea94904?s=32&d=identicon" alt="Sergey Chernov" width="32" height="32" style="vertical-align: middle; margin-right: 0.5em;" /> <b>Sergey Chernov</b> @sergeych, real.sergeych@gmail.com: Initial idea and architecture, language concept, design, implementation.
|
||||
|
||||
<br/>
|
||||
|
||||
<img src="https://www.gravatar.com/avatar/53a90bca30c85a81db8f0c0d8dea43a1?s=32&d=identicon" alt="Yulia Nezhinskaya" width="32" height="32" style="vertical-align: middle; margin-right: 0.5em;" /> <b>Yulia Nezhinskaya</b> @AlterEgoJuliaN, neleka88@gmail.com: System analysis, math and feature design.
|
||||
|
||||
|
||||
__Yulia Nezhinskaya__ @AlterEgoJuliaN: System analysis, math and features design.
|
||||
|
||||
[parallelism]: docs/parallelism.md
|
||||
@@ -1,7 +0,0 @@
|
||||
# Bytecode Migration Plan (Archived)
|
||||
|
||||
Status: completed.
|
||||
|
||||
Historical reference:
|
||||
- `notes/archive/bytecode_migration_plan.md` (full plan)
|
||||
- `notes/archive/bytecode_migration_plan_completed.md` (summary)
|
||||
@@ -4,6 +4,13 @@ It's an interface if the [Collection] that provides indexing access, like `array
|
||||
Array therefore implements [Iterable] too. Well known implementations of `Array` are
|
||||
[List] and [ImmutableList].
|
||||
|
||||
The language-level bracket syntax supports one or more selectors:
|
||||
|
||||
- `value[i]`
|
||||
- `value[i, j]`
|
||||
|
||||
Concrete array-like types decide what selectors they accept. Built-in list-like arrays use one selector at a time; custom types such as matrices may interpret multiple selectors.
|
||||
|
||||
Array adds the following methods:
|
||||
|
||||
## Binary search
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
# Complex Numbers (`lyng.complex`)
|
||||
|
||||
`lyng.complex` adds a pure-Lyng `Complex` type backed by `Real` components.
|
||||
|
||||
Import it when you want ordinary complex arithmetic:
|
||||
|
||||
```lyng
|
||||
import lyng.complex
|
||||
```
|
||||
|
||||
## Construction
|
||||
|
||||
Use any of these:
|
||||
|
||||
```lyng
|
||||
import lyng.complex
|
||||
|
||||
val a = Complex(1.0, 2.0)
|
||||
val b = complex(1.0, 2.0)
|
||||
val c = 2.i
|
||||
val d = 3.re
|
||||
|
||||
assertEquals(Complex(1.0, 2.0), 1 + 2.i)
|
||||
```
|
||||
|
||||
Convenience extensions:
|
||||
|
||||
- `Int.re`, `Real.re`: embed a real value into the complex plane
|
||||
- `Int.i`, `Real.i`: create a pure imaginary value
|
||||
- `cis(angle)`: shorthand for `cos(angle) + i sin(angle)`
|
||||
|
||||
## Core Operations
|
||||
|
||||
`Complex` supports:
|
||||
|
||||
- `+`
|
||||
- `-`
|
||||
- `*`
|
||||
- `/`
|
||||
- unary `-`
|
||||
- `conjugate`
|
||||
- `magnitude`
|
||||
- `phase`
|
||||
|
||||
Mixed arithmetic with `Int` and `Real` is enabled through `lyng.operators`, so both sides work naturally:
|
||||
|
||||
```lyng
|
||||
import lyng.complex
|
||||
|
||||
assertEquals(Complex(1.0, 2.0), 1 + 2.i)
|
||||
assertEquals(Complex(1.5, 2.0), 1.5 + 2.i)
|
||||
assertEquals(Complex(2.0, 2.0), 2.i + 2)
|
||||
```
|
||||
|
||||
Mixed equality with built-in numeric types is intentionally not promised yet. Keep equality checks in the `Complex` domain for now.
|
||||
|
||||
## Transcendental Functions
|
||||
|
||||
For now, use member-style calls:
|
||||
|
||||
```lyng
|
||||
import lyng.complex
|
||||
|
||||
val z = 1 + π.i
|
||||
val w = z.exp()
|
||||
val s = z.sin()
|
||||
val r = z.sqrt()
|
||||
```
|
||||
|
||||
This is deliberate. Lyng already has built-in top-level real-valued functions such as `exp(x)` and `sin(x)`, and imported modules do not currently replace those root bindings. So plain `exp(z)` is not yet the right extension mechanism for complex math.
|
||||
|
||||
## Design Scope
|
||||
|
||||
This module intentionally uses `Complex` with `Real` parts, not `Complex<T>`.
|
||||
|
||||
Reasons:
|
||||
|
||||
- the existing math runtime is `Real`-centric
|
||||
- the operator interop registry works with concrete runtime classes
|
||||
- transcendental functions (`exp`, `sin`, `ln`, `sqrt`) are defined over the `Real` math backend here
|
||||
|
||||
If Lyng later gets a more general numeric-trait or callable-overload registry, a generic algebraic `Complex<T>` can be revisited on firmer ground.
|
||||
@@ -223,6 +223,50 @@ assertEquals("-0.12", withDecimalContext(2, DecimalRounding.HalfTowardsZero) { (
|
||||
|
||||
## Recommended Usage Rules
|
||||
|
||||
## Decimal With Stdlib Math Functions
|
||||
|
||||
Core math helpers such as `abs`, `floor`, `ceil`, `round`, `sin`, `exp`, `ln`, `sqrt`, `log10`, `log2`, and `pow`
|
||||
now also accept `BigDecimal`.
|
||||
|
||||
Current behavior is intentionally split:
|
||||
|
||||
- exact decimal implementation:
|
||||
- `abs(x)`
|
||||
- `floor(x)`
|
||||
- `ceil(x)`
|
||||
- `round(x)`
|
||||
- `pow(x, y)` when `x` is `BigDecimal` and `y` is an integral exponent
|
||||
- temporary bridge through `Real`:
|
||||
- `sin`, `cos`, `tan`
|
||||
- `asin`, `acos`, `atan`
|
||||
- `sinh`, `cosh`, `tanh`
|
||||
- `asinh`, `acosh`, `atanh`
|
||||
- `exp`, `ln`, `log10`, `log2`
|
||||
- `sqrt`
|
||||
- `pow` for the remaining non-integral decimal exponent cases
|
||||
|
||||
The temporary bridge is:
|
||||
|
||||
```lyng
|
||||
BigDecimal -> Real -> host math -> BigDecimal
|
||||
```
|
||||
|
||||
This is a compatibility step, not the long-term design. Native decimal implementations will replace these bridge-based
|
||||
paths over time.
|
||||
|
||||
Examples:
|
||||
|
||||
```lyng
|
||||
import lyng.decimal
|
||||
|
||||
assertEquals("2.5", (abs("-2.5".d) as BigDecimal).toStringExpanded())
|
||||
assertEquals("2", (floor("2.9".d) as BigDecimal).toStringExpanded())
|
||||
|
||||
// Temporary Real bridge:
|
||||
assertEquals((exp(1.25) as Real).d.toStringExpanded(), (exp("1.25".d) as BigDecimal).toStringExpanded())
|
||||
assertEquals((sqrt(2.0) as Real).d.toStringExpanded(), (sqrt("2".d) as BigDecimal).toStringExpanded())
|
||||
```
|
||||
|
||||
If you care about exact decimal source text:
|
||||
|
||||
```lyng
|
||||
|
||||
@@ -30,6 +30,13 @@ There is a shortcut for the last:
|
||||
|
||||
__Important__ negative indexes works wherever indexes are used, e.g. in insertion and removal methods too.
|
||||
|
||||
The language also allows multi-selector indexing syntax such as `value[i, j]`, but `List` itself uses a single selector only:
|
||||
|
||||
- `list[index]` for one element
|
||||
- `list[range]` for a slice copy
|
||||
|
||||
Multi-selector indexing is intended for custom indexers such as `Matrix`.
|
||||
|
||||
## Concatenation
|
||||
|
||||
You can concatenate lists or iterable objects:
|
||||
|
||||
+192
@@ -0,0 +1,192 @@
|
||||
# Matrix (`lyng.matrix`)
|
||||
|
||||
`lyng.matrix` adds dense immutable `Matrix` and `Vector` types for linear algebra.
|
||||
|
||||
Import it when you need matrix or vector arithmetic:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
```
|
||||
|
||||
## Construction
|
||||
|
||||
Create vectors from a flat list and matrices from nested row lists:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val v: Vector = vector([1, 2, 3])
|
||||
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
|
||||
assertEquals([1.0, 2.0, 3.0], v.toList())
|
||||
assertEquals([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], m.toList())
|
||||
```
|
||||
|
||||
Factory methods are also available:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val z: Vector = Vector.zeros(3)
|
||||
val i: Matrix = Matrix.identity(3)
|
||||
val m: Matrix = Matrix.zeros(2, 4)
|
||||
```
|
||||
|
||||
All elements are standard double-precision numeric values internally.
|
||||
|
||||
## Shapes
|
||||
|
||||
Matrices may have any rectangular geometry:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
|
||||
assertEquals(2, a.rows)
|
||||
assertEquals(3, a.cols)
|
||||
assertEquals([2, 3], a.shape)
|
||||
assertEquals(false, a.isSquare)
|
||||
```
|
||||
|
||||
Vectors expose:
|
||||
|
||||
- `size`
|
||||
- `length` as an alias of `size`
|
||||
|
||||
## Matrix Operations
|
||||
|
||||
Supported matrix operations:
|
||||
|
||||
- `+` and `-` for element-wise matrix arithmetic
|
||||
- `*` for matrix-matrix product
|
||||
- `*` and `/` by a scalar
|
||||
- `transpose()`
|
||||
- `trace()`
|
||||
- `rank()`
|
||||
- `determinant()`
|
||||
- `inverse()`
|
||||
- `solve(rhs)` for `Vector` or `Matrix` right-hand sides
|
||||
|
||||
Example:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
val b: Matrix = matrix([[7, 8], [9, 10], [11, 12]])
|
||||
val product: Matrix = a * b
|
||||
assertEquals([[58.0, 64.0], [139.0, 154.0]], product.toList())
|
||||
assertEquals([[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]], a.transpose().toList())
|
||||
```
|
||||
|
||||
Inverse and solve:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[4, 7], [2, 6]])
|
||||
val rhs: Vector = vector([1, 0])
|
||||
|
||||
val inv: Matrix = a.inverse()
|
||||
val x: Vector = a.solve(rhs)
|
||||
|
||||
assert(abs(a.determinant() - 10.0) < 1e-9)
|
||||
assert(abs(inv.get(0, 0) - 0.6) < 1e-9)
|
||||
assert(abs(x.get(0) - 0.6) < 1e-9)
|
||||
```
|
||||
|
||||
## Vector Operations
|
||||
|
||||
Supported vector operations:
|
||||
|
||||
- `+` and `-`
|
||||
- scalar `*` and `/`
|
||||
- `dot(other)`
|
||||
- `norm()`
|
||||
- `normalize()`
|
||||
- `cross(other)` for 3D vectors
|
||||
- `outer(other)` producing a matrix
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val a: Vector = vector([1, 2, 3])
|
||||
val b: Vector = vector([2, 0, 0])
|
||||
|
||||
assertEquals(2.0, a.dot(b))
|
||||
assertEquals([0.2672612419124244, 0.5345224838248488, 0.8017837257372732], a.normalize().toList())
|
||||
```
|
||||
|
||||
## Indexing and Slicing
|
||||
|
||||
`Matrix` supports both method-style indexing and bracket syntax.
|
||||
|
||||
Scalar access:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
|
||||
assertEquals(6.0, m.get(1, 2))
|
||||
assertEquals(6.0, m[1, 2])
|
||||
```
|
||||
|
||||
Bracket indexing accepts two selectors: `[row, col]`.
|
||||
Each selector may be either:
|
||||
|
||||
- an `Int`
|
||||
- a `Range`
|
||||
|
||||
Examples:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val m: Matrix = matrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
|
||||
|
||||
assertEquals(7.0, m[1, 2])
|
||||
val columnSlice: Matrix = m[0..2, 2]
|
||||
val topLeft: Matrix = m[0..1, 0..1]
|
||||
val tail: Matrix = m[1.., 1..]
|
||||
assertEquals([[3.0], [7.0], [11.0]], columnSlice.toList())
|
||||
assertEquals([[1.0, 2.0], [5.0, 6.0]], topLeft.toList())
|
||||
assertEquals([[6.0, 7.0, 8.0], [10.0, 11.0, 12.0]], tail.toList())
|
||||
```
|
||||
|
||||
Shape rules:
|
||||
|
||||
- `m[Int, Int]` returns a `Real`
|
||||
- `m[Range, Int]` returns an `Nx1` `Matrix`
|
||||
- `m[Int, Range]` returns a `1xM` `Matrix`
|
||||
- `m[Range, Range]` returns a submatrix
|
||||
|
||||
Open-ended ranges are supported:
|
||||
|
||||
- `m[..1, ..1]`
|
||||
- `m[1.., 1..]`
|
||||
- `m[.., 2]`
|
||||
|
||||
Stepped ranges are not supported in matrix slicing.
|
||||
|
||||
Slices currently return new matrices, not views.
|
||||
|
||||
## Rows and Columns
|
||||
|
||||
If you want plain lists instead of a sliced matrix:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
|
||||
assertEquals([4.0, 5.0, 6.0], a.row(1))
|
||||
assertEquals([2.0, 5.0], a.column(1))
|
||||
```
|
||||
|
||||
## Backend Notes
|
||||
|
||||
The matrix module uses a platform-specific backend where available and falls back to pure Kotlin where needed.
|
||||
|
||||
The public Lyng API stays the same across platforms.
|
||||
+18
-2
@@ -1183,8 +1183,24 @@ collection's sugar won't work with it:
|
||||
assertEquals("buzz", x[0])
|
||||
>>> void
|
||||
|
||||
If you want dynamic to function like an array, create a [feature
|
||||
request](https://gitea.sergeych.net/SergeychWorks/lyng/issues).
|
||||
Multiple selectors are packed into one list index object:
|
||||
|
||||
val x = dynamic {
|
||||
get {
|
||||
if( it == [1, 2] ) "hit"
|
||||
else null
|
||||
}
|
||||
}
|
||||
assertEquals("hit", x[1, 2])
|
||||
>>> void
|
||||
|
||||
So:
|
||||
|
||||
- `x[i]` passes `i`
|
||||
- `x[i, j]` passes `[i, j]`
|
||||
- `x[i, j, k]` passes `[i, j, k]`
|
||||
|
||||
This is the same rule used by Kotlin-backed `getAt` / `putAt` indexers in embedding.
|
||||
|
||||
# Theory
|
||||
|
||||
|
||||
@@ -82,11 +82,16 @@ Primary sources used: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/{Parser,T
|
||||
- Type/containment: `is`, `!is`, `in`, `!in`, `as`, `as?`.
|
||||
- Null-safe family:
|
||||
- member access: `?.`
|
||||
- safe index: `?[i]`
|
||||
- safe index: `?[i]`, `?[i, j]`
|
||||
- safe invoke: `?(...)`
|
||||
- safe block invoke: `?{ ... }`
|
||||
- elvis: `?:` and `??`.
|
||||
- Increment/decrement: prefix and postfix `++`, `--`.
|
||||
- Indexing syntax:
|
||||
- single selector: `a[i]`
|
||||
- multiple selectors: `a[i, j, k]`
|
||||
- language-level indexing with multiple selectors is passed to `getAt`/`putAt` as one list-like index object, not as multiple method arguments.
|
||||
- example: `m[0..2, 2]`.
|
||||
|
||||
## 5. Declarations
|
||||
- Variables:
|
||||
|
||||
@@ -15,6 +15,10 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
|
||||
- Preconditions: `require`, `check`.
|
||||
- Async/concurrency: `launch`, `yield`, `flow`, `delay`.
|
||||
- Math: `floor`, `ceil`, `round`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `exp`, `ln`, `log10`, `log2`, `pow`, `sqrt`, `abs`, `clamp`.
|
||||
- These helpers also accept `lyng.decimal.BigDecimal`.
|
||||
- Exact Decimal path today: `abs`, `floor`, `ceil`, `round`, and `pow` with integral exponent.
|
||||
- Temporary Decimal path for the rest: convert `BigDecimal -> Real`, compute, then convert back to `BigDecimal`.
|
||||
- Treat that bridge as temporary; prefer native Decimal implementations when they become available.
|
||||
|
||||
## 3. Core Global Constants/Types
|
||||
- Values: `Unset`, `π`.
|
||||
@@ -56,6 +60,10 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
|
||||
## 5. Additional Built-in Modules (import explicitly)
|
||||
- `import lyng.observable`
|
||||
- `Observable`, `Subscription`, `ObservableList`, `ListChange` and change subtypes, `ChangeRejectionException`.
|
||||
- `import lyng.complex`
|
||||
- `Complex`, `complex(re, im)`, `cis(angle)`, and numeric embedding extensions such as `2.i` / `3.re`.
|
||||
- `import lyng.matrix`
|
||||
- `Matrix`, `Vector`, `matrix(rows)`, `vector(values)`, dense linear algebra, inversion, solving, and matrix slicing with `m[row, col]`.
|
||||
- `import lyng.buffer`
|
||||
- `Buffer`, `MutableBuffer`.
|
||||
- `import lyng.serialization`
|
||||
|
||||
@@ -183,6 +183,72 @@ Scope-backed Kotlin lambdas receive a `ScopeFacade` (not a full `Scope`). For mi
|
||||
|
||||
If you truly need the full `Scope` (e.g., for low-level interop), use `requireScope()` explicitly.
|
||||
|
||||
### 4.5) Indexers from Kotlin: `getAt` and `putAt`
|
||||
|
||||
Lyng bracket syntax is dispatched through `getAt` and `putAt`.
|
||||
|
||||
That means:
|
||||
|
||||
- `x[i]` calls `getAt(index)`
|
||||
- `x[i] = value` calls `putAt(index, value)` or `setAt(index, value)`
|
||||
- field-like `x["name"]` also uses the same index path unless you expose a real field/property
|
||||
|
||||
For Kotlin-backed classes, bind indexers as ordinary methods named `getAt` and `putAt`:
|
||||
|
||||
```kotlin
|
||||
moduleScope.eval("""
|
||||
extern class Grid {
|
||||
override fun getAt(index: List<Int>): Int
|
||||
override fun putAt(index: List<Int>, value: Int): void
|
||||
}
|
||||
""".trimIndent())
|
||||
|
||||
moduleScope.bind("Grid") {
|
||||
init { _ -> data = IntArray(4) }
|
||||
|
||||
addFun("getAt") {
|
||||
val index = args.requiredArg<ObjList>(0)
|
||||
val row = (index.list[0] as ObjInt).value.toInt()
|
||||
val col = (index.list[1] as ObjInt).value.toInt()
|
||||
val data = (thisObj as ObjInstance).data as IntArray
|
||||
ObjInt.of(data[row * 2 + col].toLong())
|
||||
}
|
||||
|
||||
addFun("putAt") {
|
||||
val index = args.requiredArg<ObjList>(0)
|
||||
val value = args.requiredArg<ObjInt>(1).value.toInt()
|
||||
val row = (index.list[0] as ObjInt).value.toInt()
|
||||
val col = (index.list[1] as ObjInt).value.toInt()
|
||||
val data = (thisObj as ObjInstance).data as IntArray
|
||||
data[row * 2 + col] = value
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Usage from Lyng:
|
||||
|
||||
```lyng
|
||||
val g = Grid()
|
||||
g[0, 1] = 42
|
||||
assertEquals(42, g[0, 1])
|
||||
```
|
||||
|
||||
Important rule: multiple selectors inside brackets are packed into one index object.
|
||||
So:
|
||||
|
||||
- `x[i]` passes `i`
|
||||
- `x[i, j]` passes a `List` containing `[i, j]`
|
||||
- `x[i, j, k]` passes `[i, j, k]`
|
||||
|
||||
This applies equally to:
|
||||
|
||||
- Kotlin-backed classes
|
||||
- Lyng classes overriding `getAt`
|
||||
- `dynamic { get { ... } set { ... } }`
|
||||
|
||||
If you want multi-axis slicing semantics, decode that list yourself in `getAt`.
|
||||
|
||||
### 5) Add Kotlin‑backed fields
|
||||
|
||||
If you need a simple field (with a value) instead of a computed property, use `createField`. This adds a field to the class that will be present in all its instances.
|
||||
|
||||
+73
-3
@@ -60,8 +60,13 @@ but:
|
||||
|
||||
## Round and range
|
||||
|
||||
The following functions return its argument if it is `Int`,
|
||||
or transformed `Real` otherwise.
|
||||
The following functions return the argument unchanged if it is `Int`.
|
||||
|
||||
For `BigDecimal`:
|
||||
- `floor(x)`, `ceil(x)`, and `round(x)` currently use exact decimal operations
|
||||
- the result stays `BigDecimal`
|
||||
|
||||
For `Real`, the result is a transformed `Real`.
|
||||
|
||||
| name | description |
|
||||
|----------------|--------------------------------------------------------|
|
||||
@@ -72,6 +77,14 @@ or transformed `Real` otherwise.
|
||||
|
||||
## Lyng math functions
|
||||
|
||||
Decimal note:
|
||||
- all scalar math helpers accept `BigDecimal`
|
||||
- `abs(x)` stays exact for `BigDecimal`
|
||||
- `pow(x, y)` is exact for `BigDecimal` when `y` is an integral exponent
|
||||
- the remaining `BigDecimal` cases currently use a temporary bridge:
|
||||
`BigDecimal -> Real -> host math -> BigDecimal`
|
||||
- this is temporary; native decimal implementations are planned
|
||||
|
||||
| name | meaning |
|
||||
|-----------|------------------------------------------------------|
|
||||
| sin(x) | sine |
|
||||
@@ -91,7 +104,7 @@ or transformed `Real` otherwise.
|
||||
| log10(x) | $log_{10}(x)$ |
|
||||
| pow(x, y) | ${x^y}$ |
|
||||
| sqrt(x) | $ \sqrt {x}$ |
|
||||
| abs(x) | absolute value of x. Int if x is Int, Real otherwise |
|
||||
| abs(x) | absolute value of x. Int if x is Int, BigDecimal if x is BigDecimal, Real otherwise |
|
||||
| clamp(x, range) | limit x to be inside range boundaries |
|
||||
|
||||
For example:
|
||||
@@ -104,12 +117,69 @@ For example:
|
||||
assert( abs(-1) is Int)
|
||||
assert( abs(-2.21) == 2.21 )
|
||||
|
||||
import lyng.decimal
|
||||
|
||||
// Decimal-aware math works too. Some functions are exact, some still bridge through Real temporarily:
|
||||
assert( (abs("-2.5".d) as BigDecimal).toStringExpanded() == "2.5" )
|
||||
assert( (floor("2.9".d) as BigDecimal).toStringExpanded() == "2" )
|
||||
assert( sin("0.5".d) is BigDecimal )
|
||||
|
||||
// clamp() limits value to the range:
|
||||
assert( clamp(15, 0..10) == 10 )
|
||||
assert( clamp(-5, 0..10) == 0 )
|
||||
assert( 5.clamp(0..10) == 5 )
|
||||
>>> void
|
||||
|
||||
## Linear algebra: `lyng.matrix`
|
||||
|
||||
For vectors and dense matrices, import `lyng.matrix`:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
```
|
||||
|
||||
It provides:
|
||||
|
||||
- `Vector`
|
||||
- `Matrix`
|
||||
- `vector(values)`
|
||||
- `matrix(rows)`
|
||||
|
||||
Core operations include:
|
||||
|
||||
- matrix addition and subtraction
|
||||
- matrix-matrix multiplication
|
||||
- matrix-vector multiplication
|
||||
- transpose
|
||||
- determinant
|
||||
- inverse
|
||||
- linear solve
|
||||
- vector dot, norm, normalize, cross, outer product
|
||||
|
||||
Example:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
val b: Matrix = matrix([[7, 8], [9, 10], [11, 12]])
|
||||
val product: Matrix = a * b
|
||||
assertEquals([[58.0, 64.0], [139.0, 154.0]], product.toList())
|
||||
```
|
||||
|
||||
Matrices also support two-axis bracket indexing and slicing:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
|
||||
assertEquals(6.0, m[1, 2])
|
||||
val sub: Matrix = m[0..1, 1..2]
|
||||
assertEquals([[2.0, 3.0], [5.0, 6.0]], sub.toList())
|
||||
```
|
||||
|
||||
See [Matrix](Matrix.md) for the full API.
|
||||
|
||||
## Random values
|
||||
|
||||
Lyng stdlib provides a global random singleton and deterministic seeded generators:
|
||||
|
||||
@@ -375,6 +375,18 @@ It is rather simple, like everywhere else:
|
||||
|
||||
See [math](math.md) for more on it. Notice using Greek as identifier, all languages are allowed.
|
||||
|
||||
For linear algebra, import `lyng.matrix`:
|
||||
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[1, 2], [3, 4]])
|
||||
val i: Matrix = Matrix.identity(2)
|
||||
val sum: Matrix = a + i
|
||||
assertEquals([[2.0, 2.0], [3.0, 5.0]], sum.toList())
|
||||
>>> void
|
||||
|
||||
See [Matrix](Matrix.md) for vectors, matrix multiplication, inversion, and slicing such as `m[0..2, 1]`.
|
||||
|
||||
Logical operation could be used the same
|
||||
|
||||
var x = 10
|
||||
@@ -811,6 +823,14 @@ Lists can contain any type of objects, lists too:
|
||||
|
||||
Notice usage of indexing. You can use negative indexes to offset from the end of the list; see more in [Lists](List.md).
|
||||
|
||||
In general, bracket indexing may contain more than one selector:
|
||||
|
||||
value[i]
|
||||
value[i, j]
|
||||
|
||||
For built-in lists, strings, maps, and buffers, the selector is usually a single value such as an `Int`, `Range`, or `Regex`.
|
||||
For types with custom indexers, multiple selectors are packed into one list-like index object and passed to `getAt` / `putAt`.
|
||||
|
||||
When you want to "flatten" it to single array, you can use splat syntax:
|
||||
|
||||
[1, ...[2,3], 4]
|
||||
@@ -1699,6 +1719,14 @@ Open-ended ranges could be used to get start and end too:
|
||||
assertEquals( "pult", "catapult"[ 4.. ])
|
||||
>>> void
|
||||
|
||||
The same bracket syntax is also used by imported numeric modules such as `lyng.matrix`, where indexing can be multi-axis:
|
||||
|
||||
import lyng.matrix
|
||||
|
||||
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
assertEquals(6.0, m[1, 2])
|
||||
>>> void
|
||||
|
||||
### String operations
|
||||
|
||||
Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also
|
||||
|
||||
@@ -5,6 +5,53 @@ For a programmer-focused migration summary, see `docs/whats_new_1_5.md`.
|
||||
|
||||
## Language Features
|
||||
|
||||
### Matrix and Vector Module (`lyng.matrix`)
|
||||
Lyng now ships a dense linear algebra module with immutable double-precision `Matrix` and `Vector` types.
|
||||
|
||||
It provides:
|
||||
|
||||
- `matrix([[...]])` and `vector([...])`
|
||||
- matrix multiplication
|
||||
- matrix inversion
|
||||
- determinant, trace, rank
|
||||
- solving `A * x = b`
|
||||
- vector operations such as `dot`, `normalize`, `cross`, and `outer`
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[4, 7], [2, 6]])
|
||||
val inv: Matrix = a.inverse()
|
||||
assert(abs(inv.get(0, 0) - 0.6) < 1e-9)
|
||||
```
|
||||
|
||||
Matrices also support Lyng-style slicing:
|
||||
|
||||
```lyng
|
||||
import lyng.matrix
|
||||
|
||||
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
|
||||
assertEquals(6.0, m[1, 2])
|
||||
val column: Matrix = m[0..2, 2]
|
||||
val tail: Matrix = m[1.., 1..]
|
||||
assertEquals([[3.0], [6.0], [9.0]], column.toList())
|
||||
assertEquals([[5.0, 6.0], [8.0, 9.0]], tail.toList())
|
||||
```
|
||||
|
||||
See [Matrix](Matrix.md).
|
||||
|
||||
### Multiple Selectors in Bracket Indexing
|
||||
Bracket indexing now accepts more than one selector:
|
||||
|
||||
```lyng
|
||||
value[i]
|
||||
value[i, j]
|
||||
value[i, j, k]
|
||||
```
|
||||
|
||||
For custom indexers, multiple selectors are packed into one list-like index object and dispatched through `getAt` / `putAt`.
|
||||
This is the rule used by `lyng.matrix` and by embedding APIs for Kotlin-backed indexers.
|
||||
|
||||
### Decimal Arithmetic Module (`lyng.decimal`)
|
||||
Lyng now ships a first-class decimal module built as a regular extension library rather than a deep core special case.
|
||||
|
||||
|
||||
+1
-4
@@ -27,9 +27,6 @@ kotlin.mpp.enableCInteropCommonization=true
|
||||
android.useAndroidX=true
|
||||
android.nonTransitiveRClass=true
|
||||
|
||||
# other
|
||||
kotlin.native.cacheKind.linuxX64=none
|
||||
|
||||
# Workaround: Ensure Gradle uses a JDK with `jlink` available for AGP's JDK image transform.
|
||||
# On this environment, the system JDK 21 installation lacks `jlink`, causing
|
||||
# :lynglib:androidJdkImage to fail. Point Gradle to a JDK that includes `jlink`.
|
||||
@@ -37,6 +34,6 @@ kotlin.native.cacheKind.linuxX64=none
|
||||
#org.gradle.java.home=/home/sergeych/.jdks/corretto-21.0.9
|
||||
android.experimental.lint.migrateToK2=false
|
||||
android.lint.useK2Uast=false
|
||||
kotlin.mpp.applyDefaultHierarchyTemplate=true
|
||||
kotlin.mpp.applyDefaultHierarchyTemplate=false
|
||||
|
||||
org.gradle.parallel=true
|
||||
@@ -2,13 +2,14 @@
|
||||
agp = "8.5.2"
|
||||
clikt = "5.0.3"
|
||||
mordant = "3.0.2"
|
||||
kotlin = "2.3.0"
|
||||
kotlin = "2.3.20"
|
||||
android-minSdk = "24"
|
||||
android-compileSdk = "34"
|
||||
kotlinx-coroutines = "1.10.2"
|
||||
kotlinx-datetime = "0.6.1"
|
||||
mp_bintools = "0.3.2"
|
||||
ionspin-bignum = "0.3.10"
|
||||
multik = "0.3.0"
|
||||
firebaseCrashlyticsBuildtools = "3.0.3"
|
||||
okioVersion = "3.10.2"
|
||||
compiler = "3.2.0-alpha11"
|
||||
@@ -24,6 +25,7 @@ kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-c
|
||||
kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }
|
||||
mp_bintools = { module = "net.sergeych:mp_bintools", version.ref = "mp_bintools" }
|
||||
ionspin-bignum = { module = "com.ionspin.kotlin:bignum", version.ref = "ionspin-bignum" }
|
||||
multik-default = { module = "org.jetbrains.kotlinx:multik-default", version.ref = "multik" }
|
||||
firebase-crashlytics-buildtools = { group = "com.google.firebase", name = "firebase-crashlytics-buildtools", version.ref = "firebaseCrashlyticsBuildtools" }
|
||||
okio = { module = "com.squareup.okio:okio", version.ref = "okioVersion" }
|
||||
okio-fakefilesystem = { module = "com.squareup.okio:okio-fakefilesystem", version.ref = "okioVersion" }
|
||||
|
||||
@@ -23,6 +23,8 @@ import com.intellij.execution.ui.ConsoleViewContentType
|
||||
import com.intellij.openapi.actionSystem.AnAction
|
||||
import com.intellij.openapi.actionSystem.AnActionEvent
|
||||
import com.intellij.openapi.actionSystem.CommonDataKeys
|
||||
import com.intellij.openapi.application.ApplicationManager
|
||||
import com.intellij.openapi.fileEditor.FileDocumentManager
|
||||
import com.intellij.openapi.project.Project
|
||||
import com.intellij.openapi.wm.ToolWindow
|
||||
import com.intellij.openapi.wm.ToolWindowAnchor
|
||||
@@ -36,9 +38,10 @@ import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.SupervisorJob
|
||||
import kotlinx.coroutines.launch
|
||||
import net.sergeych.lyng.idea.LyngIcons
|
||||
import java.io.File
|
||||
|
||||
class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
|
||||
private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
|
||||
private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
|
||||
|
||||
private fun getPsiFile(e: AnActionEvent): PsiFile? {
|
||||
val project = e.project ?: return null
|
||||
@@ -48,36 +51,99 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
|
||||
}
|
||||
}
|
||||
|
||||
private fun getRunnableFile(e: AnActionEvent): PsiFile? {
|
||||
val psiFile = getPsiFile(e) ?: return null
|
||||
val virtualFile = psiFile.virtualFile ?: return null
|
||||
if (!virtualFile.isInLocalFileSystem) return null
|
||||
if (!psiFile.name.endsWith(".lyng")) return null
|
||||
return psiFile
|
||||
}
|
||||
|
||||
override fun update(e: AnActionEvent) {
|
||||
val psiFile = getPsiFile(e)
|
||||
val isLyng = psiFile?.name?.endsWith(".lyng") == true
|
||||
e.presentation.isEnabledAndVisible = isLyng
|
||||
if (isLyng) {
|
||||
e.presentation.isEnabled = false
|
||||
e.presentation.text = "Run '${psiFile.name}' (disabled)"
|
||||
e.presentation.description = "Running scripts from the IDE is disabled; use the CLI."
|
||||
val psiFile = getRunnableFile(e)
|
||||
val isRunnable = psiFile != null
|
||||
e.presentation.isEnabledAndVisible = isRunnable
|
||||
if (isRunnable) {
|
||||
e.presentation.text = "Run '${psiFile.name}'"
|
||||
e.presentation.description = "Run the current Lyng script using the Lyng CLI"
|
||||
} else {
|
||||
e.presentation.text = "Run Lyng Script"
|
||||
e.presentation.description = "Run the current Lyng script"
|
||||
}
|
||||
}
|
||||
|
||||
override fun actionPerformed(e: AnActionEvent) {
|
||||
val project = e.project ?: return
|
||||
val psiFile = getPsiFile(e) ?: return
|
||||
val fileName = psiFile.name
|
||||
val psiFile = getRunnableFile(e) ?: return
|
||||
val virtualFile = psiFile.virtualFile ?: return
|
||||
FileDocumentManager.getInstance().getDocument(virtualFile)?.let { document ->
|
||||
FileDocumentManager.getInstance().saveDocument(document)
|
||||
}
|
||||
val filePath = virtualFile.path
|
||||
val workingDir = virtualFile.parent?.path ?: project.basePath ?: File(filePath).parent
|
||||
|
||||
val (console, toolWindow) = getConsoleAndToolWindow(project)
|
||||
console.clear()
|
||||
|
||||
toolWindow.show {
|
||||
scope.launch {
|
||||
console.print("--- Run is disabled ---\n", ConsoleViewContentType.SYSTEM_OUTPUT)
|
||||
console.print("Lyng now runs in bytecode-only mode; the IDE no longer evaluates scripts.\n", ConsoleViewContentType.NORMAL_OUTPUT)
|
||||
console.print("Use the CLI to run scripts, e.g. `lyng run $fileName`.\n", ConsoleViewContentType.NORMAL_OUTPUT)
|
||||
val command = startLyngProcess(filePath, workingDir)
|
||||
if (command == null) {
|
||||
printToConsole(console, "Unable to start Lyng CLI.\n", ConsoleViewContentType.ERROR_OUTPUT)
|
||||
printToConsole(console, "Tried commands: lyng, jlyng.\n", ConsoleViewContentType.ERROR_OUTPUT)
|
||||
printToConsole(console, "Install `lyng` or `jlyng` and make sure it is available on PATH.\n", ConsoleViewContentType.NORMAL_OUTPUT)
|
||||
return@launch
|
||||
}
|
||||
|
||||
printToConsole(
|
||||
console,
|
||||
"Running ${command.commandLine} in ${command.workingDir}\n",
|
||||
ConsoleViewContentType.SYSTEM_OUTPUT
|
||||
)
|
||||
streamProcess(command.process, console)
|
||||
val exitCode = command.process.waitFor()
|
||||
val outputType = if (exitCode == 0) ConsoleViewContentType.SYSTEM_OUTPUT else ConsoleViewContentType.ERROR_OUTPUT
|
||||
printToConsole(console, "\nProcess finished with exit code $exitCode\n", outputType)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun streamProcess(process: Process, console: ConsoleView) {
|
||||
val stdout = scope.launch {
|
||||
process.inputStream.bufferedReader().useLines { lines ->
|
||||
lines.forEach { printToConsole(console, "$it\n", ConsoleViewContentType.NORMAL_OUTPUT) }
|
||||
}
|
||||
}
|
||||
val stderr = scope.launch {
|
||||
process.errorStream.bufferedReader().useLines { lines ->
|
||||
lines.forEach { printToConsole(console, "$it\n", ConsoleViewContentType.ERROR_OUTPUT) }
|
||||
}
|
||||
}
|
||||
stdout.join()
|
||||
stderr.join()
|
||||
}
|
||||
|
||||
private fun printToConsole(console: ConsoleView, text: String, type: ConsoleViewContentType) {
|
||||
ApplicationManager.getApplication().invokeLater {
|
||||
console.print(text, type)
|
||||
}
|
||||
}
|
||||
|
||||
private fun startLyngProcess(filePath: String, workingDir: String?): StartedProcess? {
|
||||
val candidates = listOf("lyng", "jlyng")
|
||||
for (candidate in candidates) {
|
||||
try {
|
||||
val process = ProcessBuilder(candidate, filePath)
|
||||
.directory(workingDir?.let(::File))
|
||||
.start()
|
||||
return StartedProcess(process, "$candidate $filePath", workingDir ?: File(filePath).parent.orEmpty())
|
||||
} catch (_: java.io.IOException) {
|
||||
// Try the next candidate when the command is not available.
|
||||
}
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
private fun getConsoleAndToolWindow(project: Project): Pair<ConsoleView, ToolWindow> {
|
||||
val toolWindowManager = ToolWindowManager.getInstance(project)
|
||||
var toolWindow = toolWindowManager.getToolWindow(ToolWindowId.RUN)
|
||||
@@ -106,4 +172,10 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
|
||||
contentManager.setSelectedContent(content)
|
||||
return console to actualToolWindow
|
||||
}
|
||||
|
||||
private data class StartedProcess(
|
||||
val process: Process,
|
||||
val commandLine: String,
|
||||
val workingDir: String
|
||||
)
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -34,8 +34,10 @@ kotlin {
|
||||
// Suppress Beta warning for expect/actual classes across all targets in this module
|
||||
targets.configureEach {
|
||||
compilations.configureEach {
|
||||
compilerOptions.configure {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
compileTaskProvider.configure {
|
||||
compilerOptions {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -75,19 +77,17 @@ kotlin {
|
||||
implementation(libs.okio.fakefilesystem)
|
||||
}
|
||||
}
|
||||
val nativeMain by creating {
|
||||
dependsOn(commonMain)
|
||||
}
|
||||
val jvmTest by getting {
|
||||
dependencies {
|
||||
implementation(kotlin("test"))
|
||||
implementation(kotlin("test-junit"))
|
||||
}
|
||||
}
|
||||
// val nativeMain by getting {
|
||||
// dependencies {
|
||||
// implementation(kotlin("stdlib-common"))
|
||||
// }
|
||||
// }
|
||||
val linuxX64Main by getting {
|
||||
|
||||
dependsOn(nativeMain)
|
||||
}
|
||||
}
|
||||
}
|
||||
+26
-3
@@ -44,7 +44,6 @@ kotlin {
|
||||
iosX64()
|
||||
iosArm64()
|
||||
iosSimulatorArm64()
|
||||
macosX64()
|
||||
macosArm64()
|
||||
mingwX64()
|
||||
linuxX64()
|
||||
@@ -62,8 +61,10 @@ kotlin {
|
||||
// Keep expect/actual warning suppressed consistently with other modules
|
||||
targets.configureEach {
|
||||
compilations.configureEach {
|
||||
compilerOptions.configure {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
compileTaskProvider.configure {
|
||||
compilerOptions {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -81,11 +82,33 @@ kotlin {
|
||||
api(libs.mordant.core)
|
||||
}
|
||||
}
|
||||
val nativeMain by creating {
|
||||
dependsOn(commonMain)
|
||||
}
|
||||
val iosMain by creating {
|
||||
dependsOn(nativeMain)
|
||||
}
|
||||
val linuxMain by creating {
|
||||
dependsOn(nativeMain)
|
||||
}
|
||||
val macosMain by creating {
|
||||
dependsOn(nativeMain)
|
||||
}
|
||||
val mingwMain by creating {
|
||||
dependsOn(nativeMain)
|
||||
}
|
||||
val commonTest by getting {
|
||||
dependencies {
|
||||
implementation(libs.kotlin.test)
|
||||
}
|
||||
}
|
||||
val iosX64Main by getting { dependsOn(iosMain) }
|
||||
val iosArm64Main by getting { dependsOn(iosMain) }
|
||||
val iosSimulatorArm64Main by getting { dependsOn(iosMain) }
|
||||
val macosArm64Main by getting { dependsOn(macosMain) }
|
||||
val mingwX64Main by getting { dependsOn(mingwMain) }
|
||||
val linuxX64Main by getting { dependsOn(linuxMain) }
|
||||
val linuxArm64Main by getting { dependsOn(linuxMain) }
|
||||
|
||||
// JS: use runtime detection in jsMain to select Node vs Browser implementation
|
||||
val jsMain by getting {
|
||||
|
||||
+75
-22
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
|
||||
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
|
||||
|
||||
group = "net.sergeych"
|
||||
version = "1.5.1"
|
||||
version = "1.5.3-SNAPSHOT"
|
||||
|
||||
// Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below
|
||||
|
||||
@@ -29,7 +29,7 @@ plugins {
|
||||
alias(libs.plugins.kotlinMultiplatform)
|
||||
alias(libs.plugins.androidLibrary)
|
||||
// alias(libs.plugins.vanniktech.mavenPublish)
|
||||
kotlin("plugin.serialization") version "2.2.21"
|
||||
kotlin("plugin.serialization") version "2.3.20"
|
||||
id("com.codingfeline.buildkonfig") version "0.17.1"
|
||||
`maven-publish`
|
||||
}
|
||||
@@ -58,7 +58,6 @@ kotlin {
|
||||
iosX64()
|
||||
iosArm64()
|
||||
iosSimulatorArm64()
|
||||
macosX64()
|
||||
macosArm64()
|
||||
mingwX64()
|
||||
linuxX64()
|
||||
@@ -76,8 +75,10 @@ kotlin {
|
||||
// Suppress Beta warning for expect/actual classes across all targets
|
||||
targets.configureEach {
|
||||
compilations.configureEach {
|
||||
compilerOptions.configure {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
compileTaskProvider.configure {
|
||||
compilerOptions {
|
||||
freeCompilerArgs.add("-Xexpect-actual-classes")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -94,7 +95,7 @@ kotlin {
|
||||
}
|
||||
|
||||
val commonMain by getting {
|
||||
kotlin.srcDir("$buildDir/generated/buildConfig/commonMain/kotlin")
|
||||
kotlin.srcDir(layout.buildDirectory.dir("generated/buildConfig/commonMain/kotlin"))
|
||||
dependencies {
|
||||
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0")
|
||||
implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1")
|
||||
@@ -110,6 +111,51 @@ kotlin {
|
||||
implementation(libs.kotlinx.coroutines.test)
|
||||
}
|
||||
}
|
||||
val matrixMultikMain by creating {
|
||||
dependsOn(commonMain)
|
||||
dependencies {
|
||||
implementation(libs.multik.default)
|
||||
}
|
||||
}
|
||||
val nativeMain by creating {
|
||||
dependsOn(commonMain)
|
||||
}
|
||||
val matrixPureMain by creating {
|
||||
dependsOn(commonMain)
|
||||
}
|
||||
val jvmMain by getting { dependsOn(matrixMultikMain) }
|
||||
val androidMain by getting { dependsOn(matrixPureMain) }
|
||||
val jsMain by getting { dependsOn(matrixMultikMain) }
|
||||
val wasmJsMain by getting { dependsOn(matrixMultikMain) }
|
||||
// Multik 0.3.0 does not publish ios native artifacts, so keep iOS on the pure backend.
|
||||
val iosX64Main by getting {
|
||||
dependsOn(nativeMain)
|
||||
dependsOn(matrixPureMain)
|
||||
}
|
||||
val iosArm64Main by getting {
|
||||
dependsOn(nativeMain)
|
||||
dependsOn(matrixPureMain)
|
||||
}
|
||||
val iosSimulatorArm64Main by getting {
|
||||
dependsOn(nativeMain)
|
||||
dependsOn(matrixPureMain)
|
||||
}
|
||||
val macosArm64Main by getting {
|
||||
dependsOn(nativeMain)
|
||||
dependsOn(matrixPureMain)
|
||||
}
|
||||
val mingwX64Main by getting {
|
||||
dependsOn(nativeMain)
|
||||
dependsOn(matrixPureMain)
|
||||
}
|
||||
val linuxX64Main by getting {
|
||||
dependsOn(nativeMain)
|
||||
dependsOn(matrixPureMain)
|
||||
}
|
||||
val linuxArm64Main by getting {
|
||||
dependsOn(nativeMain)
|
||||
dependsOn(matrixPureMain)
|
||||
}
|
||||
val jvmTest by getting {
|
||||
dependencies {
|
||||
// Allow tests to load external docs like lyng.io.fs via registrar
|
||||
@@ -149,6 +195,9 @@ abstract class GenerateLyngStdlib : DefaultTask() {
|
||||
val outBase = outputDir.get().asFile
|
||||
val targetDir = outBase.resolve(pkgPath)
|
||||
targetDir.mkdirs()
|
||||
targetDir.listFiles()
|
||||
?.filter { it.isFile && it.name.endsWith(".generated.kt") }
|
||||
?.forEach { it.delete() }
|
||||
|
||||
val srcDir = sourceDir.get().asFile
|
||||
val files = srcDir.walkTopDown()
|
||||
@@ -156,34 +205,38 @@ abstract class GenerateLyngStdlib : DefaultTask() {
|
||||
.sortedBy { it.name }
|
||||
.toList()
|
||||
|
||||
val content = if (files.isEmpty()) "" else buildString {
|
||||
files.forEachIndexed { idx, f ->
|
||||
val text = f.readText()
|
||||
if (idx > 0) append("\n\n")
|
||||
append(text)
|
||||
}
|
||||
}
|
||||
|
||||
fun escapeForQuoted(s: String): String = buildString {
|
||||
for (ch in s) when (ch) {
|
||||
'\\' -> append("\\\\")
|
||||
'"' -> append("\\\"")
|
||||
'$' -> append("\\$")
|
||||
'\n' -> append("\\n")
|
||||
'\r' -> {}
|
||||
'\t' -> append("\\t")
|
||||
else -> append(ch)
|
||||
}
|
||||
}
|
||||
val body = escapeForQuoted(content)
|
||||
|
||||
val sb = StringBuilder()
|
||||
sb.append("package ").append(targetPkg).append("\n\n")
|
||||
sb.append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n")
|
||||
sb.append("internal val rootLyng = \"")
|
||||
sb.append(body)
|
||||
sb.append("\"\n")
|
||||
fun constantName(baseName: String): String {
|
||||
val parts = baseName.split(Regex("[^A-Za-z0-9]+")).filter { it.isNotEmpty() }
|
||||
if (parts.isEmpty()) return "moduleLyng"
|
||||
val head = parts.first().replaceFirstChar { it.lowercase() }
|
||||
val tail = parts.drop(1).joinToString("") { part ->
|
||||
part.replaceFirstChar { it.uppercase() }
|
||||
}
|
||||
return "${head}${tail}Lyng"
|
||||
}
|
||||
|
||||
targetDir.resolve("root_lyng.generated.kt").writeText(sb.toString())
|
||||
for (file in files) {
|
||||
val body = escapeForQuoted(file.readText())
|
||||
val sb = StringBuilder()
|
||||
sb.append("package ").append(targetPkg).append("\n\n")
|
||||
sb.append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n")
|
||||
sb.append("internal val ").append(constantName(file.nameWithoutExtension)).append(" = \"")
|
||||
sb.append(body)
|
||||
sb.append("\"\n")
|
||||
targetDir.resolve("${file.nameWithoutExtension}_lyng.generated.kt").writeText(sb.toString())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -2915,9 +2915,9 @@ class Compiler(
|
||||
operand?.let { left ->
|
||||
// array access via ObjRef
|
||||
val isOptional = t.type == Token.Type.NULL_COALESCE_INDEX
|
||||
val index = parseStatement() ?: throw ScriptError(t.pos, "Expecting index expression")
|
||||
val index = parseIndexExpression() ?: throw ScriptError(t.pos, "Expecting index expression")
|
||||
cc.skipTokenOfType(Token.Type.RBRACKET, "missing ']' at the end of the list literal")
|
||||
operand = IndexRef(left, StatementRef(index), isOptional)
|
||||
operand = IndexRef(left, index, isOptional)
|
||||
} ?: run {
|
||||
// array literal
|
||||
val entries = parseArrayLiteral()
|
||||
@@ -3412,6 +3412,20 @@ class Compiler(
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun parseIndexExpression(): ObjRef? {
|
||||
val first = parseExpressionLevel() ?: return null
|
||||
if (!cc.skipTokenOfType(Token.Type.COMMA, isOptional = true)) {
|
||||
return first
|
||||
}
|
||||
|
||||
val entries = mutableListOf<ListEntry>(ListEntry.Element(first))
|
||||
do {
|
||||
val next = parseExpressionLevel() ?: throw ScriptError(cc.currentPos(), "Expecting index expression")
|
||||
entries += ListEntry.Element(next)
|
||||
} while (cc.skipTokenOfType(Token.Type.COMMA, isOptional = true))
|
||||
return ListLiteralRef(entries)
|
||||
}
|
||||
|
||||
private suspend fun parseDestructuringPattern(): List<ListEntry> {
|
||||
// it should be called after Token.Type.LBRACKET is consumed
|
||||
val entries = mutableListOf<ListEntry>()
|
||||
@@ -8253,7 +8267,7 @@ class Compiler(
|
||||
?: context.parent?.get(localName)
|
||||
?: context.get(localName)
|
||||
?: continue
|
||||
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) {
|
||||
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty) {
|
||||
context.resolve(record, localName)
|
||||
} else {
|
||||
record.value
|
||||
|
||||
@@ -167,6 +167,19 @@ class RecordSlotRef(
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun read(scope: Scope, name: String?): Obj {
|
||||
val direct = record.value
|
||||
if (name != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || direct is ObjProperty)) {
|
||||
return scope.resolve(record, name)
|
||||
}
|
||||
return when (direct) {
|
||||
is FrameSlotRef -> direct.read()
|
||||
is RecordSlotRef -> direct.read(scope, name)
|
||||
is ScopeSlotRef -> direct.read()
|
||||
else -> direct
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun callOn(scope: Scope): Obj {
|
||||
val resolved = read()
|
||||
if (resolved === this) {
|
||||
@@ -193,4 +206,18 @@ class RecordSlotRef(
|
||||
record.value = value
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun write(scope: Scope, name: String?, value: Obj): Boolean {
|
||||
val direct = record.value
|
||||
if (name != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || direct is ObjProperty)) {
|
||||
scope.assign(record, name, value)
|
||||
return true
|
||||
}
|
||||
when (direct) {
|
||||
is ScopeSlotRef -> direct.write(value)
|
||||
is RecordSlotRef -> if (direct.write(scope, name, value)) return true else direct.write(value)
|
||||
else -> record.value = value
|
||||
}
|
||||
return false
|
||||
}
|
||||
}
|
||||
@@ -27,7 +27,9 @@ import net.sergeych.lyng.bytecode.CmdVm
|
||||
import net.sergeych.lyng.miniast.*
|
||||
import net.sergeych.lyng.obj.*
|
||||
import net.sergeych.lyng.pacman.ImportManager
|
||||
import net.sergeych.lyng.stdlib_included.complexLyng
|
||||
import net.sergeych.lyng.stdlib_included.decimalLyng
|
||||
import net.sergeych.lyng.stdlib_included.matrixLyng
|
||||
import net.sergeych.lyng.stdlib_included.observableLyng
|
||||
import net.sergeych.lyng.stdlib_included.operatorsLyng
|
||||
import net.sergeych.lyng.stdlib_included.rootLyng
|
||||
@@ -250,6 +252,44 @@ class Script(
|
||||
|
||||
companion object {
|
||||
|
||||
private suspend fun ScopeFacade.numberToDouble(value: Obj): Double =
|
||||
ObjBigDecimalSupport.toDoubleOrNull(value) ?: value.toDouble()
|
||||
|
||||
private suspend fun ScopeFacade.decimalAwareUnaryMath(
|
||||
value: Obj,
|
||||
exactDecimal: (suspend ScopeFacade.(Obj) -> Obj?)? = null,
|
||||
fallback: (Double) -> Double
|
||||
): Obj {
|
||||
exactDecimal?.let { exact ->
|
||||
exact(value)?.let { return it }
|
||||
}
|
||||
if (ObjBigDecimalSupport.isDecimalValue(value)) {
|
||||
return ObjBigDecimalSupport.fromRealLike(this, value, fallback(numberToDouble(value)))
|
||||
?: raiseIllegalState("failed to convert Real result back to BigDecimal")
|
||||
}
|
||||
return ObjReal(fallback(numberToDouble(value)))
|
||||
}
|
||||
|
||||
private suspend fun ScopeFacade.decimalAwareRoundLike(
|
||||
value: Obj,
|
||||
exactDecimal: suspend ScopeFacade.(Obj) -> Obj?,
|
||||
realFallback: (Double) -> Double
|
||||
): Obj {
|
||||
if (value is ObjInt) return value
|
||||
exactDecimal(value)?.let { return it }
|
||||
return ObjReal(realFallback(numberToDouble(value)))
|
||||
}
|
||||
|
||||
private suspend fun ScopeFacade.decimalAwarePow(base: Obj, exponent: Obj): Obj {
|
||||
ObjBigDecimalSupport.exactPow(this, base, exponent)?.let { return it }
|
||||
if (ObjBigDecimalSupport.isDecimalValue(base) || ObjBigDecimalSupport.isDecimalValue(exponent)) {
|
||||
return ObjBigDecimalSupport.fromRealLike(this, base, numberToDouble(base).pow(numberToDouble(exponent)))
|
||||
?: ObjBigDecimalSupport.fromRealLike(this, exponent, numberToDouble(base).pow(numberToDouble(exponent)))
|
||||
?: raiseIllegalState("failed to convert Real pow result back to BigDecimal")
|
||||
}
|
||||
return ObjReal(numberToDouble(base).pow(numberToDouble(exponent)))
|
||||
}
|
||||
|
||||
/**
|
||||
* Create new scope using a standard safe set of modules, using [defaultImportManager]. It is
|
||||
* suspended as first time invocation requires compilation of standard library or other
|
||||
@@ -287,87 +327,81 @@ class Script(
|
||||
}
|
||||
addFn("floor") {
|
||||
val x = args.firstAndOnly()
|
||||
(if (x is ObjInt) x
|
||||
else ObjReal(floor(x.toDouble())))
|
||||
decimalAwareRoundLike(x, ObjBigDecimalSupport::exactFloor, ::floor)
|
||||
}
|
||||
addFn("ceil") {
|
||||
val x = args.firstAndOnly()
|
||||
(if (x is ObjInt) x
|
||||
else ObjReal(ceil(x.toDouble())))
|
||||
decimalAwareRoundLike(x, ObjBigDecimalSupport::exactCeil, ::ceil)
|
||||
}
|
||||
addFn("round") {
|
||||
val x = args.firstAndOnly()
|
||||
(if (x is ObjInt) x
|
||||
else ObjReal(round(x.toDouble())))
|
||||
decimalAwareRoundLike(x, ObjBigDecimalSupport::exactRound, ::round)
|
||||
}
|
||||
|
||||
addFn("sin") {
|
||||
ObjReal(sin(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sin)
|
||||
}
|
||||
addFn("cos") {
|
||||
ObjReal(cos(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cos)
|
||||
}
|
||||
addFn("tan") {
|
||||
ObjReal(tan(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tan)
|
||||
}
|
||||
addFn("asin") {
|
||||
ObjReal(asin(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asin)
|
||||
}
|
||||
addFn("acos") {
|
||||
ObjReal(acos(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acos)
|
||||
}
|
||||
addFn("atan") {
|
||||
ObjReal(atan(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atan)
|
||||
}
|
||||
|
||||
addFn("sinh") {
|
||||
ObjReal(sinh(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sinh)
|
||||
}
|
||||
addFn("cosh") {
|
||||
ObjReal(cosh(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cosh)
|
||||
}
|
||||
addFn("tanh") {
|
||||
ObjReal(tanh(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tanh)
|
||||
}
|
||||
addFn("asinh") {
|
||||
ObjReal(asinh(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asinh)
|
||||
}
|
||||
addFn("acosh") {
|
||||
ObjReal(acosh(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acosh)
|
||||
}
|
||||
addFn("atanh") {
|
||||
ObjReal(atanh(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atanh)
|
||||
}
|
||||
|
||||
addFn("exp") {
|
||||
ObjReal(exp(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::exp)
|
||||
}
|
||||
addFn("ln") {
|
||||
ObjReal(ln(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::ln)
|
||||
}
|
||||
|
||||
addFn("log10") {
|
||||
ObjReal(log10(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log10)
|
||||
}
|
||||
|
||||
addFn("log2") {
|
||||
ObjReal(log2(args.firstAndOnly().toDouble()))
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log2)
|
||||
}
|
||||
|
||||
addFn("pow") {
|
||||
requireExactCount(2)
|
||||
ObjReal(
|
||||
(args[0].toDouble()).pow(args[1].toDouble())
|
||||
)
|
||||
decimalAwarePow(args[0], args[1])
|
||||
}
|
||||
addFn("sqrt") {
|
||||
ObjReal(
|
||||
sqrt(args.firstAndOnly().toDouble())
|
||||
)
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sqrt)
|
||||
}
|
||||
addFn("abs") {
|
||||
val x = args.firstAndOnly()
|
||||
if (x is ObjInt) ObjInt(x.value.absoluteValue) else ObjReal(x.toDouble().absoluteValue)
|
||||
if (x is ObjInt) ObjInt(x.value.absoluteValue)
|
||||
else decimalAwareUnaryMath(x, ObjBigDecimalSupport::exactAbs) { it.absoluteValue }
|
||||
}
|
||||
|
||||
addFnDoc(
|
||||
@@ -615,12 +649,88 @@ class Script(
|
||||
type = type("lyng.Real")
|
||||
)
|
||||
getOrCreateNamespace("Math").apply {
|
||||
fun ensureFn(name: String, fn: suspend ScopeFacade.() -> Obj) {
|
||||
if (members.containsKey(name)) return
|
||||
addFn(name, code = fn)
|
||||
}
|
||||
addConstDoc(
|
||||
name = "PI",
|
||||
value = pi,
|
||||
doc = "The mathematical constant pi (π) in the Math namespace.",
|
||||
type = type("lyng.Real")
|
||||
)
|
||||
ensureFn("floor") {
|
||||
val x = args.firstAndOnly()
|
||||
decimalAwareRoundLike(x, ObjBigDecimalSupport::exactFloor, ::floor)
|
||||
}
|
||||
ensureFn("ceil") {
|
||||
val x = args.firstAndOnly()
|
||||
decimalAwareRoundLike(x, ObjBigDecimalSupport::exactCeil, ::ceil)
|
||||
}
|
||||
ensureFn("round") {
|
||||
val x = args.firstAndOnly()
|
||||
decimalAwareRoundLike(x, ObjBigDecimalSupport::exactRound, ::round)
|
||||
}
|
||||
ensureFn("sin") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sin)
|
||||
}
|
||||
ensureFn("cos") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cos)
|
||||
}
|
||||
ensureFn("tan") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tan)
|
||||
}
|
||||
ensureFn("asin") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asin)
|
||||
}
|
||||
ensureFn("acos") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acos)
|
||||
}
|
||||
ensureFn("atan") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atan)
|
||||
}
|
||||
ensureFn("sinh") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sinh)
|
||||
}
|
||||
ensureFn("cosh") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cosh)
|
||||
}
|
||||
ensureFn("tanh") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tanh)
|
||||
}
|
||||
ensureFn("asinh") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asinh)
|
||||
}
|
||||
ensureFn("acosh") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acosh)
|
||||
}
|
||||
ensureFn("atanh") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atanh)
|
||||
}
|
||||
ensureFn("exp") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::exp)
|
||||
}
|
||||
ensureFn("ln") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::ln)
|
||||
}
|
||||
ensureFn("log10") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log10)
|
||||
}
|
||||
ensureFn("log2") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log2)
|
||||
}
|
||||
ensureFn("pow") {
|
||||
requireExactCount(2)
|
||||
decimalAwarePow(args[0], args[1])
|
||||
}
|
||||
ensureFn("sqrt") {
|
||||
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sqrt)
|
||||
}
|
||||
ensureFn("abs") {
|
||||
val x = args.firstAndOnly()
|
||||
if (x is ObjInt) ObjInt(x.value.absoluteValue)
|
||||
else decimalAwareUnaryMath(x, ObjBigDecimalSupport::exactAbs) { it.absoluteValue }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -759,6 +869,13 @@ class Script(
|
||||
module.eval(Source("lyng.decimal", decimalLyng))
|
||||
ObjBigDecimalSupport.bindTo(module)
|
||||
}
|
||||
addPackage("lyng.matrix") { module ->
|
||||
module.eval(Source("lyng.matrix", matrixLyng))
|
||||
ObjMatrixSupport.bindTo(module)
|
||||
}
|
||||
addPackage("lyng.complex") { module ->
|
||||
module.eval(Source("lyng.complex", complexLyng))
|
||||
}
|
||||
addPackage("lyng.buffer") {
|
||||
it.addConstDoc(
|
||||
name = "Buffer",
|
||||
|
||||
@@ -2396,7 +2396,8 @@ class BytecodeCompiler(
|
||||
builder.emit(Opcode.THROW, posId, msgSlot)
|
||||
return value
|
||||
}
|
||||
val slot = resolveSlot(localTarget)
|
||||
val slot = resolveCapturedOwnerScopeSlot(localTarget)
|
||||
?: resolveSlot(localTarget)
|
||||
?: resolveAssignableSlotByName(localTarget.name)?.first
|
||||
?: return null
|
||||
if (slot < scopeSlotCount && value.type != SlotType.UNKNOWN) {
|
||||
@@ -2702,7 +2703,7 @@ class BytecodeCompiler(
|
||||
return CompiledValue(result, SlotType.OBJ)
|
||||
}
|
||||
if (localTarget.isDelegated) return compileEvalRef(ref)
|
||||
val slot = resolveSlot(localTarget) ?: return null
|
||||
val slot = resolveCapturedOwnerScopeSlot(localTarget) ?: resolveSlot(localTarget) ?: return null
|
||||
val targetType = slotTypes[slot] ?: SlotType.OBJ
|
||||
if (!localTarget.isMutable) {
|
||||
if (targetType != SlotType.OBJ && targetType != SlotType.UNKNOWN) return compileEvalRef(ref)
|
||||
@@ -7630,6 +7631,13 @@ class BytecodeCompiler(
|
||||
return scopeSlotMap[scopeKey]
|
||||
}
|
||||
|
||||
private fun resolveCapturedOwnerScopeSlot(ref: LocalSlotRef): Int? {
|
||||
val ownerScopeId = ref.captureOwnerScopeId ?: return null
|
||||
val ownerSlot = ref.captureOwnerSlot ?: return null
|
||||
val key = ScopeSlotKey(ownerScopeId, ownerSlot)
|
||||
return scopeSlotMap[key]
|
||||
}
|
||||
|
||||
private fun updateSlotType(slot: Int, type: SlotType) {
|
||||
if (forcedObjSlots.contains(slot) && type != SlotType.OBJ) return
|
||||
if (type == SlotType.UNKNOWN) {
|
||||
|
||||
@@ -50,7 +50,7 @@ class BytecodeStatement private constructor(
|
||||
?: scope.parent?.get(name)
|
||||
?: scope.get(name)
|
||||
?: continue
|
||||
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) {
|
||||
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is net.sergeych.lyng.obj.ObjProperty) {
|
||||
scope.resolve(record, name)
|
||||
} else {
|
||||
record.value
|
||||
|
||||
@@ -85,6 +85,9 @@ class CmdNop : Cmd() {
|
||||
class CmdMoveObj(internal val src: Int, internal val dst: Int) : Cmd() {
|
||||
override suspend fun perform(frame: CmdFrame) {
|
||||
val value = frame.slotToObj(src)
|
||||
if (frame.writeThroughPropertyLikeSlot(dst, value)) {
|
||||
return
|
||||
}
|
||||
if (frame.shouldBypassImmutableWrite(dst)) {
|
||||
frame.setObjUnchecked(dst, value)
|
||||
} else {
|
||||
@@ -97,6 +100,9 @@ class CmdMoveObj(internal val src: Int, internal val dst: Int) : Cmd() {
|
||||
class CmdMoveInt(internal val src: Int, internal val dst: Int) : Cmd() {
|
||||
override suspend fun perform(frame: CmdFrame) {
|
||||
val value = frame.getInt(src)
|
||||
if (frame.writeThroughPropertyLikeSlot(dst, ObjInt.of(value))) {
|
||||
return
|
||||
}
|
||||
if (frame.shouldBypassImmutableWrite(dst)) {
|
||||
frame.setIntUnchecked(dst, value)
|
||||
} else {
|
||||
@@ -117,6 +123,9 @@ class CmdMoveIntLocal(internal val src: Int, internal val dst: Int) : Cmd() {
|
||||
class CmdMoveReal(internal val src: Int, internal val dst: Int) : Cmd() {
|
||||
override suspend fun perform(frame: CmdFrame) {
|
||||
val value = frame.getReal(src)
|
||||
if (frame.writeThroughPropertyLikeSlot(dst, ObjReal.of(value))) {
|
||||
return
|
||||
}
|
||||
if (frame.shouldBypassImmutableWrite(dst)) {
|
||||
frame.setRealUnchecked(dst, value)
|
||||
} else {
|
||||
@@ -137,6 +146,9 @@ class CmdMoveRealLocal(internal val src: Int, internal val dst: Int) : Cmd() {
|
||||
class CmdMoveBool(internal val src: Int, internal val dst: Int) : Cmd() {
|
||||
override suspend fun perform(frame: CmdFrame) {
|
||||
val value = frame.getBool(src)
|
||||
if (frame.writeThroughPropertyLikeSlot(dst, if (value) ObjTrue else ObjFalse)) {
|
||||
return
|
||||
}
|
||||
if (frame.shouldBypassImmutableWrite(dst)) {
|
||||
frame.setBoolUnchecked(dst, value)
|
||||
} else {
|
||||
@@ -2595,7 +2607,7 @@ private fun buildFunctionCaptureRecords(frame: CmdFrame, captureNames: List<Stri
|
||||
}
|
||||
val scoped = frame.scope.chainLookupIgnoreClosure(name, followClosure = true) ?: frame.scope.get(name)
|
||||
if (scoped != null) {
|
||||
records += ObjRecord(RecordSlotRef(scoped), isMutable = scoped.isMutable)
|
||||
records += scoped
|
||||
continue
|
||||
}
|
||||
frame.ensureScope().raiseSymbolNotFound("capture $name not found")
|
||||
@@ -2858,7 +2870,7 @@ class CmdDeclInstanceProperty(internal val constId: Int, internal val slot: Int)
|
||||
val decl = frame.fn.constants[constId] as? BytecodeConst.InstancePropertyDecl
|
||||
?: error("DECL_INSTANCE_PROPERTY expects InstancePropertyDecl at $constId")
|
||||
val scope = frame.ensureScope()
|
||||
val prop = frame.slotToObj(slot)
|
||||
val prop = frame.storedSlotObj(slot)
|
||||
scope.addItem(
|
||||
decl.name,
|
||||
decl.isMutable,
|
||||
@@ -3724,7 +3736,7 @@ class BytecodeLambdaCallable(
|
||||
?: context.parent?.get(name)
|
||||
?: context.get(name)
|
||||
?: continue
|
||||
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) {
|
||||
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty) {
|
||||
context.resolve(record, name)
|
||||
} else {
|
||||
record.value
|
||||
@@ -3817,7 +3829,29 @@ class CmdFrame(
|
||||
}
|
||||
|
||||
internal fun getLocalSlotTypeCode(localIndex: Int): Byte = frame.getSlotTypeCode(localIndex)
|
||||
internal fun readLocalObj(localIndex: Int): Obj = localSlotToObj(localIndex)
|
||||
internal fun readLocalObj(localIndex: Int): Obj {
|
||||
return when (frame.getSlotTypeCode(localIndex)) {
|
||||
SlotType.INT.code -> ObjInt.of(frame.getInt(localIndex))
|
||||
SlotType.REAL.code -> ObjReal.of(frame.getReal(localIndex))
|
||||
SlotType.BOOL.code -> if (frame.getBool(localIndex)) ObjTrue else ObjFalse
|
||||
SlotType.OBJ.code -> {
|
||||
val obj = frame.getObj(localIndex)
|
||||
when (obj) {
|
||||
is FrameSlotRef -> obj.read()
|
||||
is RecordSlotRef -> obj.read()
|
||||
else -> obj
|
||||
}
|
||||
}
|
||||
else -> {
|
||||
val obj = frame.getObj(localIndex)
|
||||
when (obj) {
|
||||
is FrameSlotRef -> obj.read()
|
||||
is RecordSlotRef -> obj.read()
|
||||
else -> obj
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
internal fun isFastLocalSlot(slot: Int): Boolean {
|
||||
if (slot < fn.scopeSlotCount) return false
|
||||
val localIndex = slot - fn.scopeSlotCount
|
||||
@@ -4262,7 +4296,7 @@ class CmdFrame(
|
||||
return if (slot < fn.scopeSlotCount) {
|
||||
getScopeSlotValue(slot)
|
||||
} else {
|
||||
localSlotToObj(slot - fn.scopeSlotCount)
|
||||
readLocalSlotValue(slot - fn.scopeSlotCount)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4305,6 +4339,35 @@ class CmdFrame(
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun writeThroughPropertyLikeSlot(slot: Int, value: Obj): Boolean {
|
||||
if (slot < fn.scopeSlotCount) {
|
||||
val target = scopeTarget(slot)
|
||||
val index = ensureScopeSlot(target, slot)
|
||||
val name = fn.scopeSlotNames.getOrNull(slot)
|
||||
val record = resolveScopeSlotRecordForWrite(target, index, name)
|
||||
if (name != null && record != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty)) {
|
||||
target.assign(record, name, value)
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
val localIndex = slot - fn.scopeSlotCount
|
||||
val name = fn.localSlotNames.getOrNull(localIndex) ?: return false
|
||||
val isCapture = fn.localSlotCaptures.getOrNull(localIndex) == true
|
||||
val raw = frame.getRawObj(localIndex)
|
||||
if (raw is RecordSlotRef) {
|
||||
if (raw.write(scope, name, value)) return true
|
||||
return false
|
||||
}
|
||||
if (!isCapture && raw !== ObjUnset && raw !is ObjProperty) return false
|
||||
val record = scope.parent?.get(name) ?: scope.get(name) ?: return false
|
||||
if (record.type != ObjRecord.Type.Delegated && record.type != ObjRecord.Type.Property && record.value !is ObjProperty) {
|
||||
return false
|
||||
}
|
||||
scope.assign(record, name, value)
|
||||
return true
|
||||
}
|
||||
|
||||
suspend fun getInt(slot: Int): Long {
|
||||
return if (slot < fn.scopeSlotCount) {
|
||||
getScopeSlotValue(slot).toLong()
|
||||
@@ -4314,14 +4377,7 @@ class CmdFrame(
|
||||
SlotType.INT.code -> frame.getInt(local)
|
||||
SlotType.REAL.code -> frame.getReal(local).toLong()
|
||||
SlotType.BOOL.code -> if (frame.getBool(local)) 1L else 0L
|
||||
SlotType.OBJ.code -> {
|
||||
val obj = frame.getObj(local)
|
||||
when (obj) {
|
||||
is FrameSlotRef -> obj.read().toLong()
|
||||
is RecordSlotRef -> obj.read().toLong()
|
||||
else -> obj.toLong()
|
||||
}
|
||||
}
|
||||
SlotType.OBJ.code -> readLocalSlotValue(local).toLong()
|
||||
else -> 0L
|
||||
}
|
||||
}
|
||||
@@ -4401,14 +4457,7 @@ class CmdFrame(
|
||||
SlotType.REAL.code -> frame.getReal(local)
|
||||
SlotType.INT.code -> frame.getInt(local).toDouble()
|
||||
SlotType.BOOL.code -> if (frame.getBool(local)) 1.0 else 0.0
|
||||
SlotType.OBJ.code -> {
|
||||
val obj = frame.getObj(local)
|
||||
when (obj) {
|
||||
is FrameSlotRef -> obj.read().toDouble()
|
||||
is RecordSlotRef -> obj.read().toDouble()
|
||||
else -> obj.toDouble()
|
||||
}
|
||||
}
|
||||
SlotType.OBJ.code -> readLocalSlotValue(local).toDouble()
|
||||
else -> 0.0
|
||||
}
|
||||
}
|
||||
@@ -4477,14 +4526,7 @@ class CmdFrame(
|
||||
SlotType.BOOL.code -> frame.getBool(local)
|
||||
SlotType.INT.code -> frame.getInt(local) != 0L
|
||||
SlotType.REAL.code -> frame.getReal(local) != 0.0
|
||||
SlotType.OBJ.code -> {
|
||||
val obj = frame.getObj(local)
|
||||
when (obj) {
|
||||
is FrameSlotRef -> obj.read().toBool()
|
||||
is RecordSlotRef -> obj.read().toBool()
|
||||
else -> obj.toBool()
|
||||
}
|
||||
}
|
||||
SlotType.OBJ.code -> readLocalSlotValue(local).toBool()
|
||||
else -> false
|
||||
}
|
||||
}
|
||||
@@ -4596,21 +4638,42 @@ class CmdFrame(
|
||||
}
|
||||
val local = slot - fn.scopeSlotCount
|
||||
if (fn.localSlotCaptures.getOrNull(local) == true) {
|
||||
return localSlotToObj(local)
|
||||
return readLocalSlotValue(local)
|
||||
}
|
||||
return when (frame.getSlotTypeCode(local)) {
|
||||
SlotType.INT.code -> ObjInt.of(frame.getInt(local))
|
||||
SlotType.REAL.code -> ObjReal.of(frame.getReal(local))
|
||||
SlotType.BOOL.code -> if (frame.getBool(local)) ObjTrue else ObjFalse
|
||||
SlotType.OBJ.code -> {
|
||||
val obj = frame.getObj(local)
|
||||
when (obj) {
|
||||
is FrameSlotRef -> obj.read()
|
||||
is RecordSlotRef -> obj.read()
|
||||
else -> obj
|
||||
}
|
||||
SlotType.OBJ.code -> readLocalSlotValue(local)
|
||||
else -> readLocalSlotValue(local)
|
||||
}
|
||||
}
|
||||
|
||||
fun storedSlotObj(slot: Int): Obj {
|
||||
if (slot < fn.scopeSlotCount) {
|
||||
val target = scopeTarget(slot)
|
||||
val index = ensureScopeSlot(target, slot)
|
||||
val record = target.getSlotRecord(index)
|
||||
return when (val direct = record.value) {
|
||||
is FrameSlotRef -> direct.read()
|
||||
is RecordSlotRef -> direct.read()
|
||||
is ScopeSlotRef -> direct.read()
|
||||
else -> direct
|
||||
}
|
||||
else -> localSlotToObj(local)
|
||||
}
|
||||
val local = slot - fn.scopeSlotCount
|
||||
return when (frame.getSlotTypeCode(local)) {
|
||||
SlotType.INT.code -> ObjInt.of(frame.getInt(local))
|
||||
SlotType.REAL.code -> ObjReal.of(frame.getReal(local))
|
||||
SlotType.BOOL.code -> if (frame.getBool(local)) ObjTrue else ObjFalse
|
||||
SlotType.OBJ.code, SlotType.UNKNOWN.code -> when (val raw = frame.getRawObj(local)) {
|
||||
is FrameSlotRef -> raw.read()
|
||||
is RecordSlotRef -> raw.read()
|
||||
is ScopeSlotRef -> raw.read()
|
||||
null -> ObjNull
|
||||
else -> raw
|
||||
}
|
||||
else -> frame.getRawObj(local) ?: ObjNull
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4766,7 +4829,8 @@ class CmdFrame(
|
||||
}
|
||||
}
|
||||
|
||||
private fun localSlotToObj(localIndex: Int): Obj {
|
||||
private suspend fun readLocalSlotValue(localIndex: Int): Obj {
|
||||
val localName = fn.localSlotNames.getOrNull(localIndex)
|
||||
return when (frame.getSlotTypeCode(localIndex)) {
|
||||
SlotType.INT.code -> ObjInt.of(frame.getInt(localIndex))
|
||||
SlotType.REAL.code -> ObjReal.of(frame.getReal(localIndex))
|
||||
@@ -4775,7 +4839,9 @@ class CmdFrame(
|
||||
val obj = frame.getObj(localIndex)
|
||||
when (obj) {
|
||||
is FrameSlotRef -> obj.read()
|
||||
is RecordSlotRef -> obj.read()
|
||||
is RecordSlotRef -> obj.read(scope, localName)
|
||||
is ObjProperty -> resolvePropertyLikeLocal(localName, obj)
|
||||
ObjUnset -> resolveUnsetLocal(localName)
|
||||
else -> obj
|
||||
}
|
||||
}
|
||||
@@ -4783,13 +4849,34 @@ class CmdFrame(
|
||||
val obj = frame.getObj(localIndex)
|
||||
when (obj) {
|
||||
is FrameSlotRef -> obj.read()
|
||||
is RecordSlotRef -> obj.read()
|
||||
is RecordSlotRef -> obj.read(scope, localName)
|
||||
is ObjProperty -> resolvePropertyLikeLocal(localName, obj)
|
||||
ObjUnset -> resolveUnsetLocal(localName)
|
||||
else -> obj
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun resolvePropertyLikeLocal(localName: String?, property: ObjProperty): Obj {
|
||||
if (localName != null) {
|
||||
val record = scope.parent?.get(localName) ?: scope.get(localName)
|
||||
if (record != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty)) {
|
||||
return scope.resolve(record, localName)
|
||||
}
|
||||
}
|
||||
return property.callGetter(scope, scope.thisObj)
|
||||
}
|
||||
|
||||
private suspend fun resolveUnsetLocal(localName: String?): Obj {
|
||||
if (localName == null) return ObjUnset
|
||||
val record = scope.parent?.get(localName) ?: scope.get(localName) ?: return ObjUnset
|
||||
if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty) {
|
||||
return scope.resolve(record, localName)
|
||||
}
|
||||
return record.value
|
||||
}
|
||||
|
||||
private suspend fun getScopeSlotValue(slot: Int): Obj {
|
||||
val target = scopeTarget(slot)
|
||||
val name = fn.scopeSlotNames[slot]
|
||||
@@ -4878,16 +4965,33 @@ class CmdFrame(
|
||||
private suspend fun setScopeSlotValueAtAddr(addrSlot: Int, value: Obj) {
|
||||
val target = addrScopes[addrSlot] ?: error("Address slot $addrSlot is not resolved")
|
||||
val index = addrIndices[addrSlot]
|
||||
val record = target.getSlotRecord(index)
|
||||
val slotId = addrScopeSlots[addrSlot]
|
||||
val name = fn.scopeSlotNames.getOrNull(slotId)
|
||||
if (name != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty)) {
|
||||
val record = resolveScopeSlotRecordForWrite(target, index, name)
|
||||
if (name != null && record != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty)) {
|
||||
target.assign(record, name, value)
|
||||
return
|
||||
}
|
||||
target.setSlotValue(index, value)
|
||||
}
|
||||
|
||||
private fun resolveScopeSlotRecordForWrite(target: Scope, index: Int, name: String?): ObjRecord? {
|
||||
val record = target.getSlotRecord(index)
|
||||
if (name == null) return record
|
||||
if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty) {
|
||||
return record
|
||||
}
|
||||
if (record.value !== ObjUnset && record.memberName == null) {
|
||||
return record
|
||||
}
|
||||
val resolved = target.get(name) ?: return record
|
||||
if (resolved.value !== ObjUnset || resolved.type == ObjRecord.Type.Delegated || resolved.type == ObjRecord.Type.Property || resolved.value is ObjProperty) {
|
||||
target.updateSlotFor(name, resolved)
|
||||
return resolved
|
||||
}
|
||||
return record
|
||||
}
|
||||
|
||||
internal fun ensureScopeSlot(target: Scope, slot: Int): Int {
|
||||
val name = fn.scopeSlotNames[slot]
|
||||
if (name != null) {
|
||||
|
||||
@@ -31,7 +31,7 @@ internal suspend fun seedFrameLocalsFromScope(frame: CmdFrame, scope: Scope) {
|
||||
val record = scope.getLocalRecordDirect(name)
|
||||
?: scope.chainLookupIgnoreClosure(name, followClosure = true)
|
||||
?: continue
|
||||
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) {
|
||||
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is net.sergeych.lyng.obj.ObjProperty) {
|
||||
scope.resolve(record, name)
|
||||
} else {
|
||||
record.value
|
||||
|
||||
@@ -0,0 +1,152 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.matrix
|
||||
|
||||
internal data class MatrixData(
|
||||
val rows: Int,
|
||||
val cols: Int,
|
||||
val values: DoubleArray
|
||||
) {
|
||||
init {
|
||||
require(rows > 0) { "matrix must have at least one row" }
|
||||
require(cols > 0) { "matrix must have at least one column" }
|
||||
require(values.size == rows * cols) {
|
||||
"matrix data size ${values.size} does not match shape ${rows}x${cols}"
|
||||
}
|
||||
}
|
||||
|
||||
val isSquare: Boolean get() = rows == cols
|
||||
|
||||
fun at(row: Int, col: Int): Double {
|
||||
require(row in 0 until rows) { "row index $row out of bounds for $rows rows" }
|
||||
require(col in 0 until cols) { "column index $col out of bounds for $cols columns" }
|
||||
return values[row * cols + col]
|
||||
}
|
||||
|
||||
fun rowValues(row: Int): DoubleArray {
|
||||
require(row in 0 until rows) { "row index $row out of bounds for $rows rows" }
|
||||
val start = row * cols
|
||||
return values.copyOfRange(start, start + cols)
|
||||
}
|
||||
|
||||
fun columnValues(col: Int): DoubleArray {
|
||||
require(col in 0 until cols) { "column index $col out of bounds for $cols columns" }
|
||||
return DoubleArray(rows) { row -> values[row * cols + col] }
|
||||
}
|
||||
|
||||
fun slice(rowIndices: IntArray, colIndices: IntArray): MatrixData {
|
||||
require(rowIndices.isNotEmpty()) { "matrix slice must include at least one row" }
|
||||
require(colIndices.isNotEmpty()) { "matrix slice must include at least one column" }
|
||||
val out = DoubleArray(rowIndices.size * colIndices.size)
|
||||
var offset = 0
|
||||
for (row in rowIndices) {
|
||||
require(row in 0 until rows) { "row index $row out of bounds for $rows rows" }
|
||||
val rowOffset = row * cols
|
||||
for (col in colIndices) {
|
||||
require(col in 0 until cols) { "column index $col out of bounds for $cols columns" }
|
||||
out[offset++] = values[rowOffset + col]
|
||||
}
|
||||
}
|
||||
return MatrixData(rowIndices.size, colIndices.size, out)
|
||||
}
|
||||
|
||||
fun plus(other: MatrixData): MatrixData {
|
||||
requireSameShape(other)
|
||||
return MatrixData(rows, cols, DoubleArray(values.size) { index -> values[index] + other.values[index] })
|
||||
}
|
||||
|
||||
fun minus(other: MatrixData): MatrixData {
|
||||
requireSameShape(other)
|
||||
return MatrixData(rows, cols, DoubleArray(values.size) { index -> values[index] - other.values[index] })
|
||||
}
|
||||
|
||||
fun scale(factor: Double): MatrixData =
|
||||
MatrixData(rows, cols, DoubleArray(values.size) { index -> values[index] * factor })
|
||||
|
||||
fun divide(divisor: Double): MatrixData {
|
||||
require(divisor != 0.0) { "matrix division by zero" }
|
||||
return MatrixData(rows, cols, DoubleArray(values.size) { index -> values[index] / divisor })
|
||||
}
|
||||
|
||||
fun transpose(): MatrixData {
|
||||
val out = DoubleArray(values.size)
|
||||
for (row in 0 until rows) {
|
||||
for (col in 0 until cols) {
|
||||
out[col * rows + row] = values[row * cols + col]
|
||||
}
|
||||
}
|
||||
return MatrixData(cols, rows, out)
|
||||
}
|
||||
|
||||
fun multiply(other: MatrixData): MatrixData = PlatformMatrixBackend.multiply(this, other)
|
||||
|
||||
fun multiply(other: VectorData): VectorData = PureMatrixAlgorithms.multiply(this, other)
|
||||
|
||||
fun solve(other: VectorData): VectorData = PureMatrixAlgorithms.solve(this, other)
|
||||
|
||||
fun solve(other: MatrixData): MatrixData = PureMatrixAlgorithms.solve(this, other)
|
||||
|
||||
fun determinant(): Double = PureMatrixAlgorithms.determinant(this)
|
||||
|
||||
fun inverse(): MatrixData = PlatformMatrixBackend.inverse(this)
|
||||
|
||||
fun trace(): Double = PureMatrixAlgorithms.trace(this)
|
||||
|
||||
fun rank(): Int = PureMatrixAlgorithms.rank(this)
|
||||
|
||||
fun toNestedLists(): List<List<Double>> =
|
||||
List(rows) { row ->
|
||||
List(cols) { col -> values[row * cols + col] }
|
||||
}
|
||||
|
||||
fun render(): String = buildString {
|
||||
append("Matrix(")
|
||||
append(rows)
|
||||
append("x")
|
||||
append(cols)
|
||||
append(", [")
|
||||
for (row in 0 until rows) {
|
||||
if (row > 0) append(", ")
|
||||
append("[")
|
||||
for (col in 0 until cols) {
|
||||
if (col > 0) append(", ")
|
||||
append(formatMatrixValue(values[row * cols + col]))
|
||||
}
|
||||
append("]")
|
||||
}
|
||||
append("])")
|
||||
}
|
||||
|
||||
fun compareTo(other: MatrixData): Int {
|
||||
val rowCmp = rows.compareTo(other.rows)
|
||||
if (rowCmp != 0) return rowCmp
|
||||
val colCmp = cols.compareTo(other.cols)
|
||||
if (colCmp != 0) return colCmp
|
||||
for (index in values.indices) {
|
||||
val cmp = values[index].compareTo(other.values[index])
|
||||
if (cmp != 0) return cmp
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
private fun requireSameShape(other: MatrixData) {
|
||||
require(rows == other.rows && cols == other.cols) {
|
||||
"matrix shape mismatch: ${rows}x${cols} vs ${other.rows}x${other.cols}"
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.matrix
|
||||
|
||||
import net.sergeych.lyng.obj.ObjReal
|
||||
|
||||
internal fun formatMatrixValue(value: Double): String {
|
||||
if (value.isFinite()) {
|
||||
val asLong = value.toLong()
|
||||
if (asLong.toDouble() == value) {
|
||||
return asLong.toString()
|
||||
}
|
||||
}
|
||||
return ObjReal.of(value).toString()
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.matrix
|
||||
|
||||
internal expect object PlatformMatrixBackend {
|
||||
fun multiply(left: MatrixData, right: MatrixData): MatrixData
|
||||
fun inverse(matrix: MatrixData): MatrixData
|
||||
}
|
||||
@@ -0,0 +1,286 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.matrix
|
||||
|
||||
internal object PureMatrixAlgorithms {
|
||||
private const val singularEpsilon = 1e-12
|
||||
|
||||
fun multiply(left: MatrixData, right: MatrixData): MatrixData {
|
||||
require(left.cols == right.rows) {
|
||||
"matrix multiplication shape mismatch: ${left.rows}x${left.cols} cannot multiply ${right.rows}x${right.cols}"
|
||||
}
|
||||
val out = DoubleArray(left.rows * right.cols)
|
||||
for (row in 0 until left.rows) {
|
||||
val leftRowOffset = row * left.cols
|
||||
val outRowOffset = row * right.cols
|
||||
for (pivot in 0 until left.cols) {
|
||||
val leftValue = left.values[leftRowOffset + pivot]
|
||||
val rightRowOffset = pivot * right.cols
|
||||
for (col in 0 until right.cols) {
|
||||
out[outRowOffset + col] += leftValue * right.values[rightRowOffset + col]
|
||||
}
|
||||
}
|
||||
}
|
||||
return MatrixData(left.rows, right.cols, out)
|
||||
}
|
||||
|
||||
fun multiply(left: MatrixData, right: VectorData): VectorData {
|
||||
require(left.cols == right.size) {
|
||||
"matrix-vector multiplication shape mismatch: ${left.rows}x${left.cols} cannot multiply length ${right.size}"
|
||||
}
|
||||
val out = DoubleArray(left.rows)
|
||||
for (row in 0 until left.rows) {
|
||||
var sum = 0.0
|
||||
val rowOffset = row * left.cols
|
||||
for (col in 0 until left.cols) {
|
||||
sum += left.values[rowOffset + col] * right.values[col]
|
||||
}
|
||||
out[row] = sum
|
||||
}
|
||||
return VectorData(out)
|
||||
}
|
||||
|
||||
fun inverse(matrix: MatrixData): MatrixData {
|
||||
require(matrix.isSquare) { "matrix inverse requires a square matrix, got ${matrix.rows}x${matrix.cols}" }
|
||||
val n = matrix.rows
|
||||
val width = n * 2
|
||||
val augmented = DoubleArray(n * width)
|
||||
|
||||
for (row in 0 until n) {
|
||||
for (col in 0 until n) {
|
||||
augmented[row * width + col] = matrix.values[row * n + col]
|
||||
}
|
||||
augmented[row * width + (n + row)] = 1.0
|
||||
}
|
||||
|
||||
for (pivotCol in 0 until n) {
|
||||
var pivotRow = pivotCol
|
||||
var pivotAbs = kotlin.math.abs(augmented[pivotRow * width + pivotCol])
|
||||
for (candidate in pivotCol + 1 until n) {
|
||||
val candidateAbs = kotlin.math.abs(augmented[candidate * width + pivotCol])
|
||||
if (candidateAbs > pivotAbs) {
|
||||
pivotAbs = candidateAbs
|
||||
pivotRow = candidate
|
||||
}
|
||||
}
|
||||
require(pivotAbs > singularEpsilon) { "matrix is singular and cannot be inverted" }
|
||||
if (pivotRow != pivotCol) {
|
||||
swapRows(augmented, width, pivotRow, pivotCol)
|
||||
}
|
||||
|
||||
val pivotValue = augmented[pivotCol * width + pivotCol]
|
||||
val pivotOffset = pivotCol * width
|
||||
for (col in 0 until width) {
|
||||
augmented[pivotOffset + col] /= pivotValue
|
||||
}
|
||||
|
||||
for (row in 0 until n) {
|
||||
if (row == pivotCol) continue
|
||||
val factor = augmented[row * width + pivotCol]
|
||||
if (factor == 0.0) continue
|
||||
val rowOffset = row * width
|
||||
for (col in 0 until width) {
|
||||
augmented[rowOffset + col] -= factor * augmented[pivotOffset + col]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
val inverse = DoubleArray(n * n)
|
||||
for (row in 0 until n) {
|
||||
for (col in 0 until n) {
|
||||
inverse[row * n + col] = augmented[row * width + n + col]
|
||||
}
|
||||
}
|
||||
return MatrixData(n, n, inverse)
|
||||
}
|
||||
|
||||
fun determinant(matrix: MatrixData): Double {
|
||||
require(matrix.isSquare) { "matrix determinant requires a square matrix, got ${matrix.rows}x${matrix.cols}" }
|
||||
val n = matrix.rows
|
||||
val work = matrix.values.copyOf()
|
||||
var sign = 1.0
|
||||
var determinant = 1.0
|
||||
|
||||
for (pivotCol in 0 until n) {
|
||||
var pivotRow = pivotCol
|
||||
var pivotAbs = kotlin.math.abs(work[pivotRow * n + pivotCol])
|
||||
for (candidate in pivotCol + 1 until n) {
|
||||
val candidateAbs = kotlin.math.abs(work[candidate * n + pivotCol])
|
||||
if (candidateAbs > pivotAbs) {
|
||||
pivotAbs = candidateAbs
|
||||
pivotRow = candidate
|
||||
}
|
||||
}
|
||||
if (pivotAbs <= singularEpsilon) {
|
||||
return 0.0
|
||||
}
|
||||
if (pivotRow != pivotCol) {
|
||||
swapRows(work, n, pivotRow, pivotCol)
|
||||
sign = -sign
|
||||
}
|
||||
|
||||
val pivotValue = work[pivotCol * n + pivotCol]
|
||||
determinant *= pivotValue
|
||||
|
||||
for (row in pivotCol + 1 until n) {
|
||||
val rowOffset = row * n
|
||||
val factor = work[rowOffset + pivotCol] / pivotValue
|
||||
if (factor == 0.0) continue
|
||||
for (col in pivotCol + 1 until n) {
|
||||
work[rowOffset + col] -= factor * work[pivotCol * n + col]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return determinant * sign
|
||||
}
|
||||
|
||||
fun trace(matrix: MatrixData): Double {
|
||||
require(matrix.isSquare) { "matrix trace requires a square matrix, got ${matrix.rows}x${matrix.cols}" }
|
||||
var sum = 0.0
|
||||
for (index in 0 until matrix.rows) {
|
||||
sum += matrix.values[index * matrix.cols + index]
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
fun rank(matrix: MatrixData): Int {
|
||||
val work = matrix.values.copyOf()
|
||||
var rank = 0
|
||||
var pivotRow = 0
|
||||
val rows = matrix.rows
|
||||
val cols = matrix.cols
|
||||
|
||||
for (pivotCol in 0 until cols) {
|
||||
var bestRow = -1
|
||||
var bestAbs = singularEpsilon
|
||||
for (candidate in pivotRow until rows) {
|
||||
val absValue = kotlin.math.abs(work[candidate * cols + pivotCol])
|
||||
if (absValue > bestAbs) {
|
||||
bestAbs = absValue
|
||||
bestRow = candidate
|
||||
}
|
||||
}
|
||||
if (bestRow == -1) continue
|
||||
if (bestRow != pivotRow) {
|
||||
swapRows(work, cols, bestRow, pivotRow)
|
||||
}
|
||||
val pivotValue = work[pivotRow * cols + pivotCol]
|
||||
for (row in pivotRow + 1 until rows) {
|
||||
val factor = work[row * cols + pivotCol] / pivotValue
|
||||
if (kotlin.math.abs(factor) <= singularEpsilon) continue
|
||||
val rowOffset = row * cols
|
||||
val pivotOffset = pivotRow * cols
|
||||
for (col in pivotCol until cols) {
|
||||
work[rowOffset + col] -= factor * work[pivotOffset + col]
|
||||
}
|
||||
}
|
||||
rank += 1
|
||||
pivotRow += 1
|
||||
if (pivotRow == rows) break
|
||||
}
|
||||
return rank
|
||||
}
|
||||
|
||||
fun solve(matrix: MatrixData, rhs: VectorData): VectorData {
|
||||
require(matrix.isSquare) { "matrix solve requires a square matrix, got ${matrix.rows}x${matrix.cols}" }
|
||||
require(matrix.rows == rhs.size) {
|
||||
"matrix solve shape mismatch: ${matrix.rows}x${matrix.cols} cannot solve length ${rhs.size}"
|
||||
}
|
||||
val solution = solveAugmented(matrix.rows, matrix.cols, 1, matrix.values, rhs.values)
|
||||
return VectorData(solution)
|
||||
}
|
||||
|
||||
fun solve(matrix: MatrixData, rhs: MatrixData): MatrixData {
|
||||
require(matrix.isSquare) { "matrix solve requires a square matrix, got ${matrix.rows}x${matrix.cols}" }
|
||||
require(matrix.rows == rhs.rows) {
|
||||
"matrix solve shape mismatch: ${matrix.rows}x${matrix.cols} cannot solve ${rhs.rows}x${rhs.cols}"
|
||||
}
|
||||
val solution = solveAugmented(matrix.rows, matrix.cols, rhs.cols, matrix.values, rhs.values)
|
||||
return MatrixData(matrix.rows, rhs.cols, solution)
|
||||
}
|
||||
|
||||
private fun solveAugmented(rows: Int, cols: Int, rhsCols: Int, matrixValues: DoubleArray, rhsValues: DoubleArray): DoubleArray {
|
||||
val width = cols + rhsCols
|
||||
val augmented = DoubleArray(rows * width)
|
||||
|
||||
for (row in 0 until rows) {
|
||||
val matrixOffset = row * cols
|
||||
val augmentedOffset = row * width
|
||||
for (col in 0 until cols) {
|
||||
augmented[augmentedOffset + col] = matrixValues[matrixOffset + col]
|
||||
}
|
||||
val rhsOffset = row * rhsCols
|
||||
for (col in 0 until rhsCols) {
|
||||
augmented[augmentedOffset + cols + col] = rhsValues[rhsOffset + col]
|
||||
}
|
||||
}
|
||||
|
||||
for (pivotCol in 0 until cols) {
|
||||
var pivotRow = pivotCol
|
||||
var pivotAbs = kotlin.math.abs(augmented[pivotRow * width + pivotCol])
|
||||
for (candidate in pivotCol + 1 until rows) {
|
||||
val candidateAbs = kotlin.math.abs(augmented[candidate * width + pivotCol])
|
||||
if (candidateAbs > pivotAbs) {
|
||||
pivotAbs = candidateAbs
|
||||
pivotRow = candidate
|
||||
}
|
||||
}
|
||||
require(pivotAbs > singularEpsilon) { "matrix is singular and cannot be solved" }
|
||||
if (pivotRow != pivotCol) {
|
||||
swapRows(augmented, width, pivotRow, pivotCol)
|
||||
}
|
||||
|
||||
val pivotOffset = pivotCol * width
|
||||
val pivotValue = augmented[pivotOffset + pivotCol]
|
||||
for (col in pivotCol until width) {
|
||||
augmented[pivotOffset + col] /= pivotValue
|
||||
}
|
||||
|
||||
for (row in 0 until rows) {
|
||||
if (row == pivotCol) continue
|
||||
val factor = augmented[row * width + pivotCol]
|
||||
if (kotlin.math.abs(factor) <= singularEpsilon) continue
|
||||
val rowOffset = row * width
|
||||
for (col in pivotCol until width) {
|
||||
augmented[rowOffset + col] -= factor * augmented[pivotOffset + col]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
val solution = DoubleArray(rows * rhsCols)
|
||||
for (row in 0 until rows) {
|
||||
val augmentedOffset = row * width + cols
|
||||
val solutionOffset = row * rhsCols
|
||||
for (col in 0 until rhsCols) {
|
||||
solution[solutionOffset + col] = augmented[augmentedOffset + col]
|
||||
}
|
||||
}
|
||||
return solution
|
||||
}
|
||||
|
||||
private fun swapRows(data: DoubleArray, stride: Int, firstRow: Int, secondRow: Int) {
|
||||
val firstOffset = firstRow * stride
|
||||
val secondOffset = secondRow * stride
|
||||
for (col in 0 until stride) {
|
||||
val tmp = data[firstOffset + col]
|
||||
data[firstOffset + col] = data[secondOffset + col]
|
||||
data[secondOffset + col] = tmp
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.matrix
|
||||
|
||||
import kotlin.math.sqrt
|
||||
|
||||
internal data class VectorData(
|
||||
val values: DoubleArray
|
||||
) {
|
||||
init {
|
||||
require(values.isNotEmpty()) { "vector must have at least one element" }
|
||||
}
|
||||
|
||||
val size: Int get() = values.size
|
||||
|
||||
fun at(index: Int): Double {
|
||||
require(index in values.indices) { "vector index $index out of bounds for length $size" }
|
||||
return values[index]
|
||||
}
|
||||
|
||||
fun plus(other: VectorData): VectorData {
|
||||
require(size == other.size) { "vector size mismatch: $size vs ${other.size}" }
|
||||
return VectorData(DoubleArray(size) { index -> values[index] + other.values[index] })
|
||||
}
|
||||
|
||||
fun minus(other: VectorData): VectorData {
|
||||
require(size == other.size) { "vector size mismatch: $size vs ${other.size}" }
|
||||
return VectorData(DoubleArray(size) { index -> values[index] - other.values[index] })
|
||||
}
|
||||
|
||||
fun scale(factor: Double): VectorData =
|
||||
VectorData(DoubleArray(size) { index -> values[index] * factor })
|
||||
|
||||
fun divide(divisor: Double): VectorData {
|
||||
require(divisor != 0.0) { "vector division by zero" }
|
||||
return VectorData(DoubleArray(size) { index -> values[index] / divisor })
|
||||
}
|
||||
|
||||
fun dot(other: VectorData): Double {
|
||||
require(size == other.size) { "vector size mismatch: $size vs ${other.size}" }
|
||||
var sum = 0.0
|
||||
for (index in values.indices) {
|
||||
sum += values[index] * other.values[index]
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
fun norm(): Double = sqrt(dot(this))
|
||||
|
||||
fun normalize(): VectorData {
|
||||
val length = norm()
|
||||
require(length != 0.0) { "cannot normalize a zero vector" }
|
||||
return divide(length)
|
||||
}
|
||||
|
||||
fun cross(other: VectorData): VectorData {
|
||||
require(size == 3 && other.size == 3) { "cross product requires two 3D vectors" }
|
||||
return VectorData(
|
||||
doubleArrayOf(
|
||||
values[1] * other.values[2] - values[2] * other.values[1],
|
||||
values[2] * other.values[0] - values[0] * other.values[2],
|
||||
values[0] * other.values[1] - values[1] * other.values[0]
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
fun outer(other: VectorData): MatrixData {
|
||||
val out = DoubleArray(size * other.size)
|
||||
for (row in values.indices) {
|
||||
val rowOffset = row * other.size
|
||||
for (col in other.values.indices) {
|
||||
out[rowOffset + col] = values[row] * other.values[col]
|
||||
}
|
||||
}
|
||||
return MatrixData(size, other.size, out)
|
||||
}
|
||||
|
||||
fun toList(): List<Double> = values.asList()
|
||||
|
||||
fun render(): String = buildString {
|
||||
append("Vector([")
|
||||
for (index in values.indices) {
|
||||
if (index > 0) append(", ")
|
||||
append(formatMatrixValue(values[index]))
|
||||
}
|
||||
append("])")
|
||||
}
|
||||
|
||||
fun compareTo(other: VectorData): Int {
|
||||
val sizeCmp = size.compareTo(other.size)
|
||||
if (sizeCmp != 0) return sizeCmp
|
||||
for (index in values.indices) {
|
||||
val cmp = values[index].compareTo(other.values[index])
|
||||
if (cmp != 0) return cmp
|
||||
}
|
||||
return 0
|
||||
}
|
||||
}
|
||||
@@ -448,37 +448,37 @@ private fun buildStdlibDocs(): List<MiniDecl> {
|
||||
// Math helpers (scalar versions)
|
||||
fun math1(name: String) = mod.funDoc(
|
||||
name = name,
|
||||
doc = StdlibInlineDocIndex.topFunDoc(name) ?: "Compute $name(x).",
|
||||
doc = StdlibInlineDocIndex.topFunDoc(name) ?: "Compute $name(x). Accepts Int, Real, and BigDecimal. BigDecimal currently uses a temporary Real bridge and will get native decimal implementations later.",
|
||||
params = listOf(ParamDoc("x", type("lyng.Number")))
|
||||
)
|
||||
math1("sin"); math1("cos"); math1("tan"); math1("asin"); math1("acos"); math1("atan")
|
||||
mod.funDoc(name = "floor", doc = StdlibInlineDocIndex.topFunDoc("floor") ?: "Round down the number to the nearest integer.", params = listOf(ParamDoc("x", type("lyng.Number"))))
|
||||
mod.funDoc(name = "ceil", doc = StdlibInlineDocIndex.topFunDoc("ceil") ?: "Round up the number to the nearest integer.", params = listOf(ParamDoc("x", type("lyng.Number"))))
|
||||
mod.funDoc(name = "round", doc = StdlibInlineDocIndex.topFunDoc("round") ?: "Round the number to the nearest integer.", params = listOf(ParamDoc("x", type("lyng.Number"))))
|
||||
mod.funDoc(name = "floor", doc = StdlibInlineDocIndex.topFunDoc("floor") ?: "Round down the number to the nearest integer. BigDecimal is handled directly and stays BigDecimal.", params = listOf(ParamDoc("x", type("lyng.Number"))))
|
||||
mod.funDoc(name = "ceil", doc = StdlibInlineDocIndex.topFunDoc("ceil") ?: "Round up the number to the nearest integer. BigDecimal is handled directly and stays BigDecimal.", params = listOf(ParamDoc("x", type("lyng.Number"))))
|
||||
mod.funDoc(name = "round", doc = StdlibInlineDocIndex.topFunDoc("round") ?: "Round the number to the nearest integer. BigDecimal is handled directly and stays BigDecimal.", params = listOf(ParamDoc("x", type("lyng.Number"))))
|
||||
|
||||
// Hyperbolic and inverse hyperbolic
|
||||
math1("sinh"); math1("cosh"); math1("tanh"); math1("asinh"); math1("acosh"); math1("atanh")
|
||||
|
||||
// Exponentials and logarithms
|
||||
mod.funDoc(name = "exp", doc = StdlibInlineDocIndex.topFunDoc("exp") ?: "Euler's exponential e^x.", params = listOf(ParamDoc("x", type("lyng.Number"))))
|
||||
mod.funDoc(name = "ln", doc = StdlibInlineDocIndex.topFunDoc("ln") ?: "Natural logarithm (base e).", params = listOf(ParamDoc("x", type("lyng.Number"))))
|
||||
mod.funDoc(name = "log10", doc = StdlibInlineDocIndex.topFunDoc("log10") ?: "Logarithm base 10.", params = listOf(ParamDoc("x", type("lyng.Number"))))
|
||||
mod.funDoc(name = "log2", doc = StdlibInlineDocIndex.topFunDoc("log2") ?: "Logarithm base 2.", params = listOf(ParamDoc("x", type("lyng.Number"))))
|
||||
mod.funDoc(name = "exp", doc = StdlibInlineDocIndex.topFunDoc("exp") ?: "Euler's exponential e^x. BigDecimal currently uses a temporary Real bridge and will get a native decimal implementation later.", params = listOf(ParamDoc("x", type("lyng.Number"))))
|
||||
mod.funDoc(name = "ln", doc = StdlibInlineDocIndex.topFunDoc("ln") ?: "Natural logarithm (base e). BigDecimal currently uses a temporary Real bridge and will get a native decimal implementation later.", params = listOf(ParamDoc("x", type("lyng.Number"))))
|
||||
mod.funDoc(name = "log10", doc = StdlibInlineDocIndex.topFunDoc("log10") ?: "Logarithm base 10. BigDecimal currently uses a temporary Real bridge and will get a native decimal implementation later.", params = listOf(ParamDoc("x", type("lyng.Number"))))
|
||||
mod.funDoc(name = "log2", doc = StdlibInlineDocIndex.topFunDoc("log2") ?: "Logarithm base 2. BigDecimal currently uses a temporary Real bridge and will get a native decimal implementation later.", params = listOf(ParamDoc("x", type("lyng.Number"))))
|
||||
|
||||
// Power/roots and absolute value
|
||||
mod.funDoc(
|
||||
name = "pow",
|
||||
doc = StdlibInlineDocIndex.topFunDoc("pow") ?: "Raise `x` to the power `y`.",
|
||||
doc = StdlibInlineDocIndex.topFunDoc("pow") ?: "Raise `x` to the power `y`. BigDecimal with integral `y` is handled directly; other BigDecimal cases currently use a temporary Real bridge.",
|
||||
params = listOf(ParamDoc("x", type("lyng.Number")), ParamDoc("y", type("lyng.Number")))
|
||||
)
|
||||
mod.funDoc(
|
||||
name = "sqrt",
|
||||
doc = StdlibInlineDocIndex.topFunDoc("sqrt") ?: "Square root of `x`.",
|
||||
doc = StdlibInlineDocIndex.topFunDoc("sqrt") ?: "Square root of `x`. BigDecimal currently uses a temporary Real bridge and will get a native decimal implementation later.",
|
||||
params = listOf(ParamDoc("x", type("lyng.Number")))
|
||||
)
|
||||
mod.funDoc(
|
||||
name = "abs",
|
||||
doc = StdlibInlineDocIndex.topFunDoc("abs") ?: "Absolute value of a number (works for Int and Real).",
|
||||
doc = StdlibInlineDocIndex.topFunDoc("abs") ?: "Absolute value of a number. Int stays Int, and BigDecimal stays BigDecimal.",
|
||||
params = listOf(ParamDoc("x", type("lyng.Number")))
|
||||
)
|
||||
|
||||
|
||||
@@ -591,11 +591,14 @@ open class Obj {
|
||||
return obj.copy(value = res, type = ObjRecord.Type.Other)
|
||||
}
|
||||
val value = obj.value
|
||||
if (value is ObjProperty || obj.type == ObjRecord.Type.Property) {
|
||||
val prop = (value as? ObjProperty)
|
||||
?: scope.raiseError("Expected ObjProperty for property member $name, got ${value::class}")
|
||||
val res = prop.callGetter(scope, this, decl)
|
||||
return ObjRecord(res, obj.isMutable)
|
||||
if (value is ObjProperty) {
|
||||
val res = value.callGetter(scope, this, decl)
|
||||
return obj.copy(value = res, type = ObjRecord.Type.Other)
|
||||
}
|
||||
if (obj.type == ObjRecord.Type.Property) {
|
||||
// Some runtime paths cache the resolved property value back into the record.
|
||||
// Treat that as an already-resolved read result instead of trying to call a getter again.
|
||||
return obj.copy(type = ObjRecord.Type.Other)
|
||||
}
|
||||
val caller = scope.currentClassCtx
|
||||
// Check visibility for non-property members here if they weren't checked before
|
||||
|
||||
@@ -17,22 +17,14 @@
|
||||
|
||||
package net.sergeych.lyng.obj
|
||||
|
||||
import com.ionspin.kotlin.bignum.decimal.BigDecimal as IonBigDecimal
|
||||
import com.ionspin.kotlin.bignum.decimal.DecimalMode
|
||||
import com.ionspin.kotlin.bignum.decimal.RoundingMode
|
||||
import com.ionspin.kotlin.bignum.integer.BigInteger
|
||||
import net.sergeych.lyng.Arguments
|
||||
import net.sergeych.lyng.FrameSlotRef
|
||||
import net.sergeych.lyng.InteropOperator
|
||||
import net.sergeych.lyng.ModuleScope
|
||||
import net.sergeych.lyng.OperatorInteropRegistry
|
||||
import net.sergeych.lyng.RecordSlotRef
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.ScopeFacade
|
||||
import net.sergeych.lyng.TypeDecl
|
||||
import net.sergeych.lyng.*
|
||||
import net.sergeych.lyng.miniast.addPropertyDoc
|
||||
import net.sergeych.lyng.miniast.type
|
||||
import net.sergeych.lyng.requiredArg
|
||||
import com.ionspin.kotlin.bignum.decimal.BigDecimal as IonBigDecimal
|
||||
|
||||
object ObjBigDecimalSupport {
|
||||
private const val decimalContextVar = "__lyng_decimal_context__"
|
||||
@@ -88,6 +80,9 @@ object ObjBigDecimalSupport {
|
||||
decimalClass.addFn("toReal") {
|
||||
ObjReal.of(valueOf(thisObj).doubleValue(false))
|
||||
}
|
||||
decimalClass.addFn("toString") {
|
||||
ObjString(valueOf(thisObj).toStringExpanded())
|
||||
}
|
||||
decimalClass.addFn("toStringExpanded") {
|
||||
ObjString(valueOf(thisObj).toStringExpanded())
|
||||
}
|
||||
@@ -133,6 +128,37 @@ object ObjBigDecimalSupport {
|
||||
registerInterop(decimalClass)
|
||||
}
|
||||
|
||||
fun isDecimalValue(value: Obj): Boolean =
|
||||
value is ObjInstance && value.objClass.className == "BigDecimal"
|
||||
|
||||
suspend fun exactAbs(scope: ScopeFacade, value: Obj): Obj? =
|
||||
decimalValueOrNull(value)?.let { scope.newInstanceLikeDecimal(value, it.abs()) }
|
||||
|
||||
suspend fun exactFloor(scope: ScopeFacade, value: Obj): Obj? =
|
||||
decimalValueOrNull(value)?.let { scope.newInstanceLikeDecimal(value, it.floor()) }
|
||||
|
||||
suspend fun exactCeil(scope: ScopeFacade, value: Obj): Obj? =
|
||||
decimalValueOrNull(value)?.let { scope.newInstanceLikeDecimal(value, it.ceil()) }
|
||||
|
||||
suspend fun exactRound(scope: ScopeFacade, value: Obj): Obj? =
|
||||
decimalValueOrNull(value)?.let {
|
||||
scope.newInstanceLikeDecimal(value, it.roundToDigitPositionAfterDecimalPoint(0, RoundingMode.ROUND_HALF_CEILING))
|
||||
}
|
||||
|
||||
suspend fun exactPow(scope: ScopeFacade, base: Obj, exponent: Obj): Obj? {
|
||||
val decimal = decimalValueOrNull(base) ?: return null
|
||||
val intExponent = exponent as? ObjInt ?: return null
|
||||
return scope.newInstanceLikeDecimal(base, decimal.pow(intExponent.value))
|
||||
}
|
||||
|
||||
suspend fun fromRealLike(scope: ScopeFacade, sample: Obj, value: Double): Obj? {
|
||||
if (!isDecimalValue(sample)) return null
|
||||
return scope.newInstanceLikeDecimal(sample, IonBigDecimal.fromDouble(value, realConversionMode))
|
||||
}
|
||||
|
||||
fun toDoubleOrNull(value: Obj): Double? =
|
||||
decimalValueOrNull(value)?.doubleValue(false)
|
||||
|
||||
private fun valueOf(obj: Obj): IonBigDecimal {
|
||||
val instance = obj as? ObjInstance ?: error("BigDecimal receiver must be an object instance")
|
||||
return instance.kotlinInstanceData as? IonBigDecimal ?: zero
|
||||
@@ -165,6 +191,12 @@ object ObjBigDecimalSupport {
|
||||
return instance
|
||||
}
|
||||
|
||||
private suspend fun ScopeFacade.newInstanceLikeDecimal(sample: Obj, value: IonBigDecimal): ObjInstance {
|
||||
val decimalClass = (sample as? ObjInstance)?.objClass
|
||||
?: raiseIllegalState("BigDecimal sample must be an object instance")
|
||||
return newInstance(decimalClass, value)
|
||||
}
|
||||
|
||||
private fun coerceArg(scope: Scope, value: Obj): IonBigDecimal = when (value) {
|
||||
is ObjInt -> IonBigDecimal.fromLongAsSignificand(value.value)
|
||||
is ObjReal -> IonBigDecimal.fromDouble(value.value, realConversionMode)
|
||||
@@ -253,6 +285,12 @@ object ObjBigDecimalSupport {
|
||||
}
|
||||
}
|
||||
|
||||
private fun decimalValueOrNull(value: Obj): IonBigDecimal? {
|
||||
if (!isDecimalValue(value)) return null
|
||||
val instance = value as ObjInstance
|
||||
return instance.kotlinInstanceData as? IonBigDecimal ?: zero
|
||||
}
|
||||
|
||||
private fun registerBuiltinConversions(decimalClass: ObjClass) {
|
||||
ObjInt.type.addPropertyDoc(
|
||||
name = "d",
|
||||
|
||||
@@ -0,0 +1,385 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.obj
|
||||
|
||||
import net.sergeych.lyng.ModuleScope
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.ScopeFacade
|
||||
import net.sergeych.lyng.matrix.MatrixData
|
||||
import net.sergeych.lyng.matrix.VectorData
|
||||
import net.sergeych.lyng.requiredArg
|
||||
|
||||
object ObjMatrixSupport {
|
||||
private sealed interface MatrixAxisIndex {
|
||||
data class Single(val value: Int) : MatrixAxisIndex
|
||||
data class Slice(val values: IntArray) : MatrixAxisIndex
|
||||
}
|
||||
|
||||
private object BoundMarker
|
||||
private val defaultMatrix = MatrixData(1, 1, doubleArrayOf(0.0))
|
||||
private val defaultVector = VectorData(doubleArrayOf(0.0))
|
||||
|
||||
suspend fun bindTo(module: ModuleScope) {
|
||||
val matrixClass = module.requireClass("Matrix")
|
||||
val vectorClass = module.requireClass("Vector")
|
||||
if (matrixClass.kotlinClassData === BoundMarker && vectorClass.kotlinClassData === BoundMarker) return
|
||||
|
||||
bindVectorClass(vectorClass, matrixClass)
|
||||
bindMatrixClass(matrixClass, vectorClass)
|
||||
}
|
||||
|
||||
private fun bindVectorClass(vectorClass: ObjClass, matrixClass: ObjClass) {
|
||||
if (vectorClass.kotlinClassData === BoundMarker) return
|
||||
vectorClass.kotlinClassData = BoundMarker
|
||||
vectorClass.isAbstract = false
|
||||
|
||||
val hooks = vectorClass.bridgeInitHooks ?: mutableListOf<suspend (ScopeFacade, ObjInstance) -> Unit>().also {
|
||||
vectorClass.bridgeInitHooks = it
|
||||
}
|
||||
hooks += { _, instance -> instance.kotlinInstanceData = defaultVector }
|
||||
|
||||
vectorClass.addProperty("size", getter = {
|
||||
ObjInt.of(vectorOf(thisObj).size.toLong())
|
||||
})
|
||||
vectorClass.addProperty("length", getter = {
|
||||
ObjInt.of(vectorOf(thisObj).size.toLong())
|
||||
})
|
||||
vectorClass.addFn("toList") {
|
||||
Obj.from(vectorOf(thisObj).toList())
|
||||
}
|
||||
vectorClass.addFn("get") {
|
||||
ObjReal.of(vectorOf(thisObj).at(requiredArg<ObjInt>(0).value.toInt()))
|
||||
}
|
||||
vectorClass.addFn("plus") {
|
||||
newVector(vectorClass, vectorOf(thisObj).plus(coerceVectorArg(requireScope(), args.firstAndOnly())))
|
||||
}
|
||||
vectorClass.addFn("minus") {
|
||||
newVector(vectorClass, vectorOf(thisObj).minus(coerceVectorArg(requireScope(), args.firstAndOnly())))
|
||||
}
|
||||
vectorClass.addFn("mul") {
|
||||
newVector(vectorClass, vectorOf(thisObj).scale(coerceScalarArg(requireScope(), args.firstAndOnly())))
|
||||
}
|
||||
vectorClass.addFn("div") {
|
||||
newVector(vectorClass, vectorOf(thisObj).divide(coerceScalarArg(requireScope(), args.firstAndOnly())))
|
||||
}
|
||||
vectorClass.addFn("dot") {
|
||||
ObjReal.of(vectorOf(thisObj).dot(coerceVectorArg(requireScope(), args.firstAndOnly())))
|
||||
}
|
||||
vectorClass.addFn("norm") {
|
||||
ObjReal.of(vectorOf(thisObj).norm())
|
||||
}
|
||||
vectorClass.addFn("normalize") {
|
||||
newVector(vectorClass, vectorOf(thisObj).normalize())
|
||||
}
|
||||
vectorClass.addFn("cross") {
|
||||
newVector(vectorClass, vectorOf(thisObj).cross(coerceVectorArg(requireScope(), args.firstAndOnly())))
|
||||
}
|
||||
vectorClass.addFn("outer") {
|
||||
newMatrix(matrixClass, vectorOf(thisObj).outer(coerceVectorArg(requireScope(), args.firstAndOnly())))
|
||||
}
|
||||
vectorClass.addFn("toString") {
|
||||
ObjString(vectorOf(thisObj).render())
|
||||
}
|
||||
vectorClass.addFn("compareTo") {
|
||||
ObjInt.of(vectorOf(thisObj).compareTo(coerceVectorArg(requireScope(), args.firstAndOnly())).toLong())
|
||||
}
|
||||
|
||||
vectorClass.addClassFn("fromList") {
|
||||
newVector(vectorClass, parseVector(requireScope(), requiredArg(0)))
|
||||
}
|
||||
vectorClass.addClassFn("zeros") {
|
||||
val size = requiredArg<ObjInt>(0).value.toInt()
|
||||
if (size <= 0) requireScope().raiseIllegalArgument("vector size must be positive")
|
||||
newVector(vectorClass, VectorData(DoubleArray(size)))
|
||||
}
|
||||
}
|
||||
|
||||
private fun bindMatrixClass(matrixClass: ObjClass, vectorClass: ObjClass) {
|
||||
if (matrixClass.kotlinClassData === BoundMarker) return
|
||||
matrixClass.kotlinClassData = BoundMarker
|
||||
matrixClass.isAbstract = false
|
||||
|
||||
val hooks = matrixClass.bridgeInitHooks ?: mutableListOf<suspend (ScopeFacade, ObjInstance) -> Unit>().also {
|
||||
matrixClass.bridgeInitHooks = it
|
||||
}
|
||||
hooks += { _, instance -> instance.kotlinInstanceData = defaultMatrix }
|
||||
|
||||
matrixClass.addProperty("rows", getter = {
|
||||
ObjInt.of(matrixOf(thisObj).rows.toLong())
|
||||
})
|
||||
matrixClass.addProperty("cols", getter = {
|
||||
ObjInt.of(matrixOf(thisObj).cols.toLong())
|
||||
})
|
||||
matrixClass.addProperty("shape", getter = {
|
||||
ObjList(
|
||||
mutableListOf(
|
||||
ObjInt.of(matrixOf(thisObj).rows.toLong()),
|
||||
ObjInt.of(matrixOf(thisObj).cols.toLong())
|
||||
)
|
||||
)
|
||||
})
|
||||
matrixClass.addProperty("isSquare", getter = {
|
||||
matrixOf(thisObj).isSquare.toObj()
|
||||
})
|
||||
|
||||
matrixClass.addFn("plus") {
|
||||
newMatrix(matrixClass, matrixOf(thisObj).plus(coerceMatrixArg(requireScope(), args.firstAndOnly())))
|
||||
}
|
||||
matrixClass.addFn("minus") {
|
||||
newMatrix(matrixClass, matrixOf(thisObj).minus(coerceMatrixArg(requireScope(), args.firstAndOnly())))
|
||||
}
|
||||
matrixClass.addFn("mul") {
|
||||
when (val other = args.firstAndOnly()) {
|
||||
is ObjInstance -> when (other.objClass.className) {
|
||||
"Matrix" -> newMatrix(matrixClass, matrixOf(thisObj).multiply(matrixOf(other)))
|
||||
"Vector" -> newVector(vectorClass, matrixOf(thisObj).multiply(vectorOf(other)))
|
||||
else -> newMatrix(matrixClass, matrixOf(thisObj).scale(coerceScalarArg(requireScope(), other)))
|
||||
}
|
||||
else -> newMatrix(matrixClass, matrixOf(thisObj).scale(coerceScalarArg(requireScope(), other)))
|
||||
}
|
||||
}
|
||||
matrixClass.addFn("div") {
|
||||
newMatrix(matrixClass, matrixOf(thisObj).divide(coerceScalarArg(requireScope(), args.firstAndOnly())))
|
||||
}
|
||||
matrixClass.addFn("transpose") {
|
||||
newMatrix(matrixClass, matrixOf(thisObj).transpose())
|
||||
}
|
||||
matrixClass.addFn("trace") {
|
||||
ObjReal.of(matrixOf(thisObj).trace())
|
||||
}
|
||||
matrixClass.addFn("rank") {
|
||||
ObjInt.of(matrixOf(thisObj).rank().toLong())
|
||||
}
|
||||
matrixClass.addFn("determinant") {
|
||||
ObjReal.of(matrixOf(thisObj).determinant())
|
||||
}
|
||||
matrixClass.addFn("inverse") {
|
||||
newMatrix(matrixClass, matrixOf(thisObj).inverse())
|
||||
}
|
||||
matrixClass.addFn("solve") {
|
||||
when (val rhs = args.firstAndOnly()) {
|
||||
is ObjInstance -> when (rhs.objClass.className) {
|
||||
"Vector" -> newVector(vectorClass, matrixOf(thisObj).solve(vectorOf(rhs)))
|
||||
"Matrix" -> newMatrix(matrixClass, matrixOf(thisObj).solve(matrixOf(rhs)))
|
||||
else -> requireScope().raiseClassCastError("Matrix.solve expects Vector or Matrix")
|
||||
}
|
||||
else -> requireScope().raiseClassCastError("Matrix.solve expects Vector or Matrix")
|
||||
}
|
||||
}
|
||||
matrixClass.addFn("get") {
|
||||
ObjReal.of(
|
||||
matrixOf(thisObj).at(
|
||||
requiredArg<ObjInt>(0).value.toInt(),
|
||||
requiredArg<ObjInt>(1).value.toInt()
|
||||
)
|
||||
)
|
||||
}
|
||||
matrixClass.addFn("getAt") {
|
||||
resolveMatrixIndex(matrixClass, matrixOf(thisObj), args.firstAndOnly(), thisObj)
|
||||
}
|
||||
matrixClass.addFn("row") {
|
||||
doubleArrayToObjList(matrixOf(thisObj).rowValues(requiredArg<ObjInt>(0).value.toInt()))
|
||||
}
|
||||
matrixClass.addFn("column") {
|
||||
doubleArrayToObjList(matrixOf(thisObj).columnValues(requiredArg<ObjInt>(0).value.toInt()))
|
||||
}
|
||||
matrixClass.addFn("toList") {
|
||||
Obj.from(matrixOf(thisObj).toNestedLists())
|
||||
}
|
||||
matrixClass.addFn("toString") {
|
||||
ObjString(matrixOf(thisObj).render())
|
||||
}
|
||||
matrixClass.addFn("compareTo") {
|
||||
ObjInt.of(matrixOf(thisObj).compareTo(coerceMatrixArg(requireScope(), args.firstAndOnly())).toLong())
|
||||
}
|
||||
|
||||
matrixClass.addClassFn("fromRows") {
|
||||
newMatrix(matrixClass, parseRows(requireScope(), requiredArg(0)))
|
||||
}
|
||||
matrixClass.addClassFn("zeros") {
|
||||
val rows = requiredArg<ObjInt>(0).value.toInt()
|
||||
val cols = requiredArg<ObjInt>(1).value.toInt()
|
||||
if (rows <= 0) requireScope().raiseIllegalArgument("matrix must have at least one row")
|
||||
if (cols <= 0) requireScope().raiseIllegalArgument("matrix must have at least one column")
|
||||
newMatrix(matrixClass, MatrixData(rows, cols, DoubleArray(rows * cols)))
|
||||
}
|
||||
matrixClass.addClassFn("identity") {
|
||||
val size = requiredArg<ObjInt>(0).value.toInt()
|
||||
if (size <= 0) requireScope().raiseIllegalArgument("identity matrix size must be positive")
|
||||
val values = DoubleArray(size * size)
|
||||
for (index in 0 until size) {
|
||||
values[index * size + index] = 1.0
|
||||
}
|
||||
newMatrix(matrixClass, MatrixData(size, size, values))
|
||||
}
|
||||
}
|
||||
|
||||
private fun matrixOf(obj: Obj): MatrixData {
|
||||
val instance = obj as? ObjInstance ?: error("Matrix receiver must be an object instance")
|
||||
return instance.kotlinInstanceData as? MatrixData ?: defaultMatrix
|
||||
}
|
||||
|
||||
private fun vectorOf(obj: Obj): VectorData {
|
||||
val instance = obj as? ObjInstance ?: error("Vector receiver must be an object instance")
|
||||
return instance.kotlinInstanceData as? VectorData ?: defaultVector
|
||||
}
|
||||
|
||||
private suspend fun ScopeFacade.newMatrix(matrixClass: ObjClass, value: MatrixData): ObjInstance {
|
||||
val instance = call(matrixClass) as? ObjInstance
|
||||
?: raiseIllegalState("Matrix() did not return an object instance")
|
||||
instance.kotlinInstanceData = value
|
||||
return instance
|
||||
}
|
||||
|
||||
private suspend fun ScopeFacade.newVector(vectorClass: ObjClass, value: VectorData): ObjInstance {
|
||||
val instance = call(vectorClass) as? ObjInstance
|
||||
?: raiseIllegalState("Vector() did not return an object instance")
|
||||
instance.kotlinInstanceData = value
|
||||
return instance
|
||||
}
|
||||
|
||||
private fun coerceMatrixArg(scope: Scope, value: Obj): MatrixData {
|
||||
val instance = value as? ObjInstance
|
||||
?: scope.raiseClassCastError("expected Matrix, got ${value.objClass.className}")
|
||||
if (instance.objClass.className != "Matrix") {
|
||||
scope.raiseClassCastError("expected Matrix, got ${instance.objClass.className}")
|
||||
}
|
||||
return instance.kotlinInstanceData as? MatrixData ?: defaultMatrix
|
||||
}
|
||||
|
||||
private fun coerceVectorArg(scope: Scope, value: Obj): VectorData {
|
||||
val instance = value as? ObjInstance
|
||||
?: scope.raiseClassCastError("expected Vector, got ${value.objClass.className}")
|
||||
if (instance.objClass.className != "Vector") {
|
||||
scope.raiseClassCastError("expected Vector, got ${instance.objClass.className}")
|
||||
}
|
||||
return instance.kotlinInstanceData as? VectorData ?: defaultVector
|
||||
}
|
||||
|
||||
private fun coerceScalarArg(scope: Scope, value: Obj): Double = try {
|
||||
value.toDouble()
|
||||
} catch (_: IllegalArgumentException) {
|
||||
scope.raiseClassCastError("expected matrix scalar (Int or Real), got ${value.objClass.className}")
|
||||
}
|
||||
|
||||
private suspend fun parseRows(scope: Scope, rowsObj: Obj): MatrixData {
|
||||
val outer = asObjList(scope, rowsObj, "Matrix.fromRows expects a list of rows")
|
||||
if (outer.list.isEmpty()) scope.raiseIllegalArgument("matrix must have at least one row")
|
||||
|
||||
val rows = outer.list.size
|
||||
var cols = -1
|
||||
val values = mutableListOf<Double>()
|
||||
|
||||
for (rowObj in outer.list) {
|
||||
val row = asObjList(scope, rowObj, "Matrix rows must be lists")
|
||||
if (cols == -1) {
|
||||
cols = row.list.size
|
||||
if (cols <= 0) scope.raiseIllegalArgument("matrix must have at least one column")
|
||||
} else if (row.list.size != cols) {
|
||||
scope.raiseIllegalArgument("matrix rows must all have the same length")
|
||||
}
|
||||
for (cell in row.list) {
|
||||
values += coerceScalarArg(scope, cell)
|
||||
}
|
||||
}
|
||||
return MatrixData(rows, cols, values.toDoubleArray())
|
||||
}
|
||||
|
||||
private suspend fun parseVector(scope: Scope, valuesObj: Obj): VectorData {
|
||||
val list = asObjList(scope, valuesObj, "Vector.fromList expects a list")
|
||||
if (list.list.isEmpty()) scope.raiseIllegalArgument("vector must have at least one element")
|
||||
return VectorData(list.list.map { coerceScalarArg(scope, it) }.toDoubleArray())
|
||||
}
|
||||
|
||||
private suspend fun ScopeFacade.resolveMatrixIndex(
|
||||
matrixClass: ObjClass,
|
||||
matrix: MatrixData,
|
||||
index: Obj,
|
||||
receiver: Obj
|
||||
): Obj {
|
||||
val tuple = asObjList(requireScope(), index, "Matrix index must be [row, col]")
|
||||
if (tuple.list.size != 2) {
|
||||
raiseIllegalArgument("Matrix index must contain exactly two selectors: [row, col]")
|
||||
}
|
||||
|
||||
val rowIndex = decodeAxisIndex(requireScope(), tuple.list[0], matrix.rows, "row")
|
||||
val colIndex = decodeAxisIndex(requireScope(), tuple.list[1], matrix.cols, "column")
|
||||
|
||||
return when {
|
||||
rowIndex is MatrixAxisIndex.Single && colIndex is MatrixAxisIndex.Single ->
|
||||
ObjReal.of(matrix.at(rowIndex.value, colIndex.value))
|
||||
|
||||
rowIndex is MatrixAxisIndex.Single && colIndex is MatrixAxisIndex.Slice ->
|
||||
newMatrix(matrixClass, matrix.slice(intArrayOf(rowIndex.value), colIndex.values))
|
||||
|
||||
rowIndex is MatrixAxisIndex.Slice && colIndex is MatrixAxisIndex.Single ->
|
||||
newMatrix(matrixClass, matrix.slice(rowIndex.values, intArrayOf(colIndex.value)))
|
||||
|
||||
rowIndex is MatrixAxisIndex.Slice && colIndex is MatrixAxisIndex.Slice ->
|
||||
newMatrix(matrixClass, matrix.slice(rowIndex.values, colIndex.values))
|
||||
|
||||
else -> requireScope().raiseIllegalState("unreachable matrix index state for ${receiver.objClass.className}")
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun decodeAxisIndex(scope: Scope, index: Obj, size: Int, axisName: String): MatrixAxisIndex =
|
||||
when (index) {
|
||||
is ObjInt -> {
|
||||
val value = index.value.toInt()
|
||||
if (value !in 0 until size) {
|
||||
scope.raiseIllegalArgument("$axisName index $value out of bounds for length $size")
|
||||
}
|
||||
MatrixAxisIndex.Single(value)
|
||||
}
|
||||
|
||||
is ObjRange -> {
|
||||
if (index.hasExplicitStep) {
|
||||
scope.raiseIllegalArgument("Matrix slicing does not support stepped $axisName ranges")
|
||||
}
|
||||
val start = index.startInt(scope)
|
||||
val endExclusive = index.exclusiveIntEnd(scope) ?: size
|
||||
if (start !in 0..size) {
|
||||
scope.raiseIllegalArgument("$axisName slice start $start out of bounds for length $size")
|
||||
}
|
||||
if (endExclusive !in 0..size) {
|
||||
scope.raiseIllegalArgument("$axisName slice end $endExclusive out of bounds for length $size")
|
||||
}
|
||||
if (start > endExclusive) {
|
||||
scope.raiseIllegalArgument("$axisName slice start $start is after end $endExclusive")
|
||||
}
|
||||
if (start == endExclusive) {
|
||||
scope.raiseIllegalArgument("Matrix slice must include at least one $axisName")
|
||||
}
|
||||
MatrixAxisIndex.Slice(IntArray(endExclusive - start) { start + it })
|
||||
}
|
||||
|
||||
else -> scope.raiseClassCastError("Matrix $axisName selector must be Int or Range, got ${index.objClass.className}")
|
||||
}
|
||||
|
||||
private suspend fun asObjList(scope: Scope, value: Obj, message: String): ObjList = when (value) {
|
||||
is ObjList -> value
|
||||
else -> if (value.isInstanceOf(ObjIterable)) {
|
||||
value.callMethod<ObjList>(scope, "toList")
|
||||
} else {
|
||||
scope.raiseClassCastError(message)
|
||||
}
|
||||
}
|
||||
|
||||
private fun doubleArrayToObjList(values: DoubleArray): ObjList =
|
||||
ObjList(values.map { ObjReal.of(it) }.toMutableList())
|
||||
}
|
||||
@@ -18,8 +18,14 @@
|
||||
package net.sergeych.lyng
|
||||
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import net.sergeych.lyng.bridge.bind
|
||||
import net.sergeych.lyng.obj.ObjRecord
|
||||
import net.sergeych.lyng.bridge.data
|
||||
import net.sergeych.lyng.bridge.bindGlobalVar
|
||||
import net.sergeych.lyng.bridge.globalBinder
|
||||
import net.sergeych.lyng.obj.ObjFalse
|
||||
import net.sergeych.lyng.obj.ObjInstance
|
||||
import net.sergeych.lyng.obj.ObjTrue
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
|
||||
@@ -49,4 +55,97 @@ class GlobalPropertyCaptureRegressionTest {
|
||||
|
||||
assertEquals(2.0, x, "bound extern var should stay live inside function bodies")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun externGlobalVarShouldStayLiveWhenScriptRunsInChildScope() = runTest {
|
||||
val base = Script.newScope() as ModuleScope
|
||||
var x = 1.0
|
||||
|
||||
base.eval("extern var X: Real")
|
||||
base.globalBinder().bindGlobalVar(
|
||||
name = "X",
|
||||
get = { x },
|
||||
set = { x = it }
|
||||
)
|
||||
|
||||
val child = base.createChildScope()
|
||||
child.eval(
|
||||
Source(
|
||||
"child-scope-probe",
|
||||
"""
|
||||
fun main() {
|
||||
X = X + 1.0
|
||||
}
|
||||
""".trimIndent()
|
||||
)
|
||||
)
|
||||
|
||||
val mainRecord = child["main"]
|
||||
check(mainRecord?.type == ObjRecord.Type.Fun)
|
||||
child.eval("main()")
|
||||
|
||||
assertEquals(2.0, x, "bound extern var should stay live in child-scope execution")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun externGlobalVarShouldStayLiveAfterExternClassPropertyBranchInChildScope() = runTest {
|
||||
val base = Script.newScope() as ModuleScope
|
||||
var x = 3.0
|
||||
|
||||
base.eval(
|
||||
"""
|
||||
extern var X: Real
|
||||
|
||||
class ChoiceInputResult {
|
||||
extern val isSkip: Bool
|
||||
}
|
||||
|
||||
extern fun requestChoice(): ChoiceInputResult
|
||||
""".trimIndent()
|
||||
)
|
||||
|
||||
base.bind("ChoiceInputResult") {
|
||||
addVal("isSkip") {
|
||||
if (thisObjData<ChoicePayload>().isSkip) ObjTrue else ObjFalse
|
||||
}
|
||||
}
|
||||
|
||||
base.globalBinder().bindGlobalVar(
|
||||
name = "X",
|
||||
get = { x },
|
||||
set = { x = it }
|
||||
)
|
||||
|
||||
base.globalBinder().bindGlobalFunRaw("requestChoice") { _, _ ->
|
||||
val instance = base.requireClass("ChoiceInputResult").callOn(base.createChildScope()) as ObjInstance
|
||||
instance.data = ChoicePayload(isSkip = true)
|
||||
instance
|
||||
}
|
||||
|
||||
val child = base.createChildScope()
|
||||
child.eval(
|
||||
"""
|
||||
fun main() {
|
||||
val c: ChoiceInputResult = requestChoice()
|
||||
if (c.isSkip) {
|
||||
X = 77.0
|
||||
}
|
||||
}
|
||||
""".trimIndent()
|
||||
)
|
||||
|
||||
child.eval("main()")
|
||||
|
||||
assertEquals(77.0, x, "bound extern var should stay live after extern class property branch in child scope")
|
||||
}
|
||||
}
|
||||
|
||||
private data class ChoicePayload(
|
||||
val isSkip: Boolean,
|
||||
)
|
||||
|
||||
@Suppress("UNCHECKED_CAST")
|
||||
private fun <T> ScopeFacade.thisObjData(): T {
|
||||
val instance = thisObj as? ObjInstance ?: raiseClassCastError("Expected result object instance")
|
||||
return instance.data as? T ?: raiseIllegalState("Bridge payload is not initialized")
|
||||
}
|
||||
@@ -135,4 +135,95 @@ class BigDecimalModuleTest {
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testDefaultToString() = runTest {
|
||||
eval("""
|
||||
import lyng.decimal
|
||||
|
||||
var s0 = "0.1".d + "0.1".d
|
||||
assertEquals("0.2", s0.toStringExpanded())
|
||||
assertEquals("0.2", s0.toString())
|
||||
""".trimIndent())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testDecimalMathHelpersUseExactImplementationsWhenAvailable() = runTest {
|
||||
val scope = Script.newScope()
|
||||
scope.eval(
|
||||
"""
|
||||
import lyng.decimal
|
||||
|
||||
val absValue = abs("-2.5".d) as BigDecimal
|
||||
val floorPos = floor("2.9".d) as BigDecimal
|
||||
val floorNeg = floor("-2.1".d) as BigDecimal
|
||||
val ceilPos = ceil("2.1".d) as BigDecimal
|
||||
val ceilNeg = ceil("-2.1".d) as BigDecimal
|
||||
val roundPos = round("2.5".d) as BigDecimal
|
||||
val roundNeg = round("-2.5".d) as BigDecimal
|
||||
val powInt = pow("1.5".d, 2) as BigDecimal
|
||||
|
||||
assertEquals("2.5", absValue.toStringExpanded())
|
||||
assertEquals("2", floorPos.toStringExpanded())
|
||||
assertEquals("-3", floorNeg.toStringExpanded())
|
||||
assertEquals("3", ceilPos.toStringExpanded())
|
||||
assertEquals("-2", ceilNeg.toStringExpanded())
|
||||
assertEquals("3", roundPos.toStringExpanded())
|
||||
assertEquals("-2", roundNeg.toStringExpanded())
|
||||
assertEquals("2.25", powInt.toStringExpanded())
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testDecimalMathHelpersFallbackThroughRealTemporarily() = runTest {
|
||||
val scope = Script.newScope()
|
||||
scope.eval(
|
||||
"""
|
||||
import lyng.decimal
|
||||
|
||||
val sinDecimal = sin("0.5".d) as BigDecimal
|
||||
val expDecimal = exp("1.25".d) as BigDecimal
|
||||
val sqrtDecimal = sqrt("2".d) as BigDecimal
|
||||
val lnDecimal = ln("2".d) as BigDecimal
|
||||
val log10Decimal = log10("2".d) as BigDecimal
|
||||
val log2Decimal = log2("2".d) as BigDecimal
|
||||
val powDecimal = pow("2".d, "0.5".d) as BigDecimal
|
||||
|
||||
assertEquals((sin(0.5) as Real).d.toStringExpanded(), sinDecimal.toStringExpanded())
|
||||
assertEquals((exp(1.25) as Real).d.toStringExpanded(), expDecimal.toStringExpanded())
|
||||
assertEquals((sqrt(2.0) as Real).d.toStringExpanded(), sqrtDecimal.toStringExpanded())
|
||||
assertEquals((ln(2.0) as Real).d.toStringExpanded(), lnDecimal.toStringExpanded())
|
||||
assertEquals((log10(2.0) as Real).d.toStringExpanded(), log10Decimal.toStringExpanded())
|
||||
assertEquals((log2(2.0) as Real).d.toStringExpanded(), log2Decimal.toStringExpanded())
|
||||
assertEquals((pow(2.0, 0.5) as Real).d.toStringExpanded(), powDecimal.toStringExpanded())
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun decimalMustBeObj() = runTest {
|
||||
eval("""
|
||||
import lyng.decimal
|
||||
|
||||
val decimal = 42.d
|
||||
val context = DecimalContext(12)
|
||||
|
||||
assert(decimal is BigDecimal)
|
||||
assertEquals(BigDecimal, decimal::class)
|
||||
|
||||
assert(context is DecimalContext)
|
||||
assertEquals(DecimalContext, context::class)
|
||||
""".trimIndent())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testFromRealLife1() = runTest {
|
||||
eval("""
|
||||
import lyng.decimal
|
||||
var X = 42.d
|
||||
X += 11
|
||||
assertEquals(53.d, X)
|
||||
""")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import kotlin.test.Test
|
||||
|
||||
class ComplexModuleTest {
|
||||
@Test
|
||||
fun testComplexArithmeticAndInterop() = runTest {
|
||||
val scope = Script.newScope()
|
||||
scope.eval(
|
||||
"""
|
||||
import lyng.complex
|
||||
|
||||
assertEquals(Complex(0.0, 2.0), 2.i)
|
||||
assertEquals(Complex(2.0, 0.0), 2.re)
|
||||
assertEquals(Complex(1.0, 2.0), 1 + 2.i)
|
||||
assertEquals(Complex(1.5, 2.0), 1.5 + 2.i)
|
||||
assertEquals(Complex(3.0, 2.0), 1 + Complex(2.0, 2.0))
|
||||
val product: Complex = Complex(1.0, 2.0) * Complex(3.0, -1.0)
|
||||
assertEquals(5.0, product.re)
|
||||
assertEquals(5.0, product.im)
|
||||
val quotient: Complex = Complex(5.0, 5.0) / Complex(3.0, -1.0)
|
||||
assertEquals(1.0, quotient.re)
|
||||
assertEquals(2.0, quotient.im)
|
||||
assertEquals(Complex(1.0, -2.0), Complex(1.0, 2.0).conjugate)
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testComplexMemberMathFunctions() = runTest {
|
||||
val scope = Script.newScope()
|
||||
scope.eval(
|
||||
"""
|
||||
import lyng.complex
|
||||
|
||||
val eps = 1e-9
|
||||
|
||||
val eipi = Complex.imaginary(π).exp()
|
||||
assert(abs(eipi.re + 1.0) < eps)
|
||||
assert(abs(eipi.im) < eps)
|
||||
|
||||
val iy: Complex = 2.i
|
||||
val sinIy = iy.sin()
|
||||
assert(abs(sinIy.re) < eps)
|
||||
assert(abs(sinIy.im - sinh(2.0)) < eps)
|
||||
|
||||
val minusOne: Complex = (-1).re
|
||||
val root = minusOne.sqrt()
|
||||
assert(abs(root.re) < eps)
|
||||
assert(abs(root.im - 1.0) < eps)
|
||||
|
||||
val unitLeft: Complex = cis(π)
|
||||
assert(abs(unitLeft.re + 1.0) < eps)
|
||||
assert(abs(unitLeft.im) < eps)
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,171 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import kotlin.test.Test
|
||||
|
||||
class MatrixModuleTest {
|
||||
@Test
|
||||
fun testMatrixConstructionAndShape() = runTest {
|
||||
val scope = Script.newScope()
|
||||
scope.eval(
|
||||
"""
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
val v: Vector = vector([1, 2, 3])
|
||||
assertEquals(2, a.rows)
|
||||
assertEquals(3, a.cols)
|
||||
assertEquals([2, 3], a.shape)
|
||||
assertEquals(false, a.isSquare)
|
||||
assertEquals([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], a.toList())
|
||||
assertEquals("Matrix(2x3, [[1, 2, 3], [4, 5, 6]])", a.toString())
|
||||
assertEquals(3, v.size)
|
||||
assertEquals([1.0, 2.0, 3.0], v.toList())
|
||||
assertEquals("Vector([1, 2, 3])", v.toString())
|
||||
assertEquals([0.2672612419124244, 0.5345224838248488, 0.8017837257372732], v.normalize().toList())
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testMatrixArithmeticAndTranspose() = runTest {
|
||||
val scope = Script.newScope()
|
||||
scope.eval(
|
||||
"""
|
||||
import lyng.matrix
|
||||
|
||||
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
|
||||
val b: Matrix = matrix([[7, 8], [9, 10], [11, 12]])
|
||||
val product: Matrix = a * b
|
||||
assertEquals([[58.0, 64.0], [139.0, 154.0]], product.toList())
|
||||
|
||||
val scaled: Matrix = product * 0.5
|
||||
assertEquals([[29.0, 32.0], [69.5, 77.0]], scaled.toList())
|
||||
|
||||
val sum: Matrix = matrix([[1, 2], [3, 4]]) + Matrix.identity(2)
|
||||
assertEquals([[2.0, 2.0], [3.0, 5.0]], sum.toList())
|
||||
|
||||
val transposed: Matrix = a.transpose()
|
||||
assertEquals([[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]], transposed.toList())
|
||||
assertEquals([4.0, 5.0, 6.0], a.row(1))
|
||||
assertEquals([2.0, 5.0], a.column(1))
|
||||
|
||||
val x: Vector = vector([1, 0.5, -1])
|
||||
val y: Vector = a * x
|
||||
assertEquals([-1.0, 0.5], y.toList())
|
||||
|
||||
val shifted: Vector = x + vector([2, 2, 2])
|
||||
assertEquals([3.0, 2.5, 1.0], shifted.toList())
|
||||
val d0: Vector = vector([1, 2, 3])
|
||||
val d1: Vector = vector([2, 0, 0])
|
||||
assertEquals(2.0, d0.dot(d1))
|
||||
val cx0: Vector = vector([1, 0, 0])
|
||||
val cx1: Vector = vector([0, 1, 0])
|
||||
assertEquals([0.0, 0.0, 1.0], cx0.cross(cx1).toList())
|
||||
val o0: Vector = vector([1.5, 3.0])
|
||||
val o1: Vector = vector([2, 2.6666666666666665])
|
||||
assertEquals([[3.0, 4.0], [6.0, 8.0]], o0.outer(o1).toList())
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testMatrixDeterminantAndInverse() = runTest {
|
||||
val scope = Script.newScope()
|
||||
scope.eval(
|
||||
"""
|
||||
import lyng.matrix
|
||||
|
||||
val eps = 1e-9
|
||||
val a: Matrix = matrix([[4, 7], [2, 6]])
|
||||
assert(abs(a.determinant() - 10.0) < eps)
|
||||
assertEquals(10.0, a.trace())
|
||||
assertEquals(2, a.rank())
|
||||
|
||||
val inv: Matrix = a.inverse()
|
||||
assert(abs(inv.get(0, 0) - 0.6) < eps)
|
||||
assert(abs(inv.get(0, 1) + 0.7) < eps)
|
||||
assert(abs(inv.get(1, 0) + 0.2) < eps)
|
||||
assert(abs(inv.get(1, 1) - 0.4) < eps)
|
||||
|
||||
val identity: Matrix = a * inv
|
||||
assert(abs(identity.get(0, 0) - 1.0) < eps)
|
||||
assert(abs(identity.get(0, 1)) < eps)
|
||||
assert(abs(identity.get(1, 0)) < eps)
|
||||
assert(abs(identity.get(1, 1) - 1.0) < eps)
|
||||
|
||||
val rhs: Vector = vector([1, 0])
|
||||
val solution: Vector = a.solve(rhs)
|
||||
assert(abs(solution.get(0) - 0.6) < eps)
|
||||
assert(abs(solution.get(1) + 0.2) < eps)
|
||||
|
||||
val rhsMatrix: Matrix = Matrix.identity(2)
|
||||
val solvedMatrix: Matrix = a.solve(rhsMatrix)
|
||||
assert(abs(solvedMatrix.get(0, 0) - 0.6) < eps)
|
||||
assert(abs(solvedMatrix.get(1, 1) - 0.4) < eps)
|
||||
|
||||
val lowRank: Matrix = matrix([[1, 2], [2, 4]])
|
||||
assertEquals(1, lowRank.rank())
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testMatrixBracketIndexingAndSlices() = runTest {
|
||||
val scope = Script.newScope()
|
||||
scope.eval(
|
||||
"""
|
||||
import lyng.matrix
|
||||
|
||||
val m: Matrix = matrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
|
||||
|
||||
assertEquals(7.0, m[1, 2])
|
||||
|
||||
val columnSlice: Matrix = m[0..2, 2]
|
||||
assertEquals([[3.0], [7.0], [11.0]], columnSlice.toList())
|
||||
|
||||
val topLeft: Matrix = m[0..1, 0..1]
|
||||
assertEquals([[1.0, 2.0], [5.0, 6.0]], topLeft.toList())
|
||||
|
||||
val tail: Matrix = m[1.., 1..]
|
||||
assertEquals([[6.0, 7.0, 8.0], [10.0, 11.0, 12.0]], tail.toList())
|
||||
|
||||
val rowSlice: Matrix = m[1, 1..2]
|
||||
assertEquals([[6.0, 7.0]], rowSlice.toList())
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun matrixAndVectorMustBeObjs() = runTest {
|
||||
eval("""
|
||||
import lyng.matrix
|
||||
|
||||
val matrixValue = matrix([[1, 2], [3, 4]])
|
||||
val vectorValue = vector([1, 2, 3])
|
||||
|
||||
assert(matrixValue is Matrix)
|
||||
assertEquals(Matrix, matrixValue::class)
|
||||
|
||||
assert(vectorValue is Vector)
|
||||
assertEquals(Vector, vectorValue::class)
|
||||
""".trimIndent())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import kotlin.test.Test
|
||||
|
||||
class RandomModuleTest {
|
||||
@Test
|
||||
fun seededRandomMustBeObj() = runTest {
|
||||
eval("""
|
||||
val rng = Random.seeded(12345)
|
||||
|
||||
assert(rng is SeededRandom)
|
||||
assertEquals(SeededRandom, rng::class)
|
||||
""".trimIndent())
|
||||
}
|
||||
}
|
||||
+53
@@ -0,0 +1,53 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.matrix
|
||||
|
||||
import org.jetbrains.kotlinx.multik.api.mk
|
||||
import org.jetbrains.kotlinx.multik.api.ndarray
|
||||
import org.jetbrains.kotlinx.multik.api.linalg.dot
|
||||
import org.jetbrains.kotlinx.multik.api.linalg.inv
|
||||
import org.jetbrains.kotlinx.multik.ndarray.data.get
|
||||
|
||||
internal actual object PlatformMatrixBackend {
|
||||
actual fun multiply(left: MatrixData, right: MatrixData): MatrixData {
|
||||
require(left.cols == right.rows) {
|
||||
"matrix multiplication shape mismatch: ${left.rows}x${left.cols} cannot multiply ${right.rows}x${right.cols}"
|
||||
}
|
||||
val leftArray = mk.ndarray(left.values, left.rows, left.cols)
|
||||
val rightArray = mk.ndarray(right.values, right.rows, right.cols)
|
||||
val product = leftArray dot rightArray
|
||||
return MatrixData(left.rows, right.cols, extract(product, left.rows, right.cols))
|
||||
}
|
||||
|
||||
actual fun inverse(matrix: MatrixData): MatrixData {
|
||||
require(matrix.isSquare) { "matrix inverse requires a square matrix, got ${matrix.rows}x${matrix.cols}" }
|
||||
val source = mk.ndarray(matrix.values, matrix.rows, matrix.cols)
|
||||
val inverse = mk.linalg.inv(source)
|
||||
return MatrixData(matrix.rows, matrix.cols, extract(inverse, matrix.rows, matrix.cols))
|
||||
}
|
||||
|
||||
private fun extract(array: org.jetbrains.kotlinx.multik.ndarray.data.D2Array<Double>, rows: Int, cols: Int): DoubleArray {
|
||||
val out = DoubleArray(rows * cols)
|
||||
for (row in 0 until rows) {
|
||||
for (col in 0 until cols) {
|
||||
out[row * cols + col] = array[row, col]
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
}
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.matrix
|
||||
|
||||
internal actual object PlatformMatrixBackend {
|
||||
actual fun multiply(left: MatrixData, right: MatrixData): MatrixData =
|
||||
PureMatrixAlgorithms.multiply(left, right)
|
||||
|
||||
actual fun inverse(matrix: MatrixData): MatrixData =
|
||||
PureMatrixAlgorithms.inverse(matrix)
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
package lyng.complex
|
||||
|
||||
import lyng.operators
|
||||
|
||||
/*
|
||||
Complex number backed by `Real` components.
|
||||
|
||||
This module intentionally keeps the storage model simple:
|
||||
- `re`: real part
|
||||
- `im`: imaginary part
|
||||
|
||||
The algebra is implemented in pure Lyng and interoperates with `Int` and `Real`
|
||||
through `lyng.operators`, so expressions like `1 + 2.i` and `0.5 * (1 + 2.i)` work.
|
||||
|
||||
For transcendental functions, use the member-style API for now:
|
||||
- `z.exp()`
|
||||
- `z.ln()`
|
||||
- `z.sin()`
|
||||
- `z.cos()`
|
||||
- `z.tan()`
|
||||
- `z.sqrt()`
|
||||
|
||||
This avoids collisions with the built-in real-valued top-level math functions
|
||||
such as `exp(x)` and `sin(x)`.
|
||||
*/
|
||||
class Complex(val real: Real, val imag: Real = 0.0) {
|
||||
val re get() = real
|
||||
val im get() = imag
|
||||
|
||||
fun plus(other: Complex): Complex = Complex(real + other.real, imag + other.imag)
|
||||
|
||||
fun minus(other: Complex): Complex = Complex(real - other.real, imag - other.imag)
|
||||
|
||||
fun mul(other: Complex): Complex =
|
||||
Complex(
|
||||
real * other.real - imag * other.imag,
|
||||
real * other.imag + imag * other.real
|
||||
)
|
||||
|
||||
fun div(other: Complex): Complex {
|
||||
val denominator = other.real * other.real + other.imag * other.imag
|
||||
Complex(
|
||||
(real * other.real + imag * other.imag) / denominator,
|
||||
(imag * other.real - real * other.imag) / denominator
|
||||
)
|
||||
}
|
||||
|
||||
fun negate(): Complex = Complex(-real, -imag)
|
||||
|
||||
val conjugate get() = Complex(real, -imag)
|
||||
val magnitude2 get() = real * real + imag * imag
|
||||
val magnitude get() = Math.sqrt(magnitude2)
|
||||
|
||||
val phase: Real
|
||||
get() = if (real > 0.0) {
|
||||
Math.atan(imag / real)
|
||||
} else if (real < 0.0 && imag >= 0.0) {
|
||||
Math.atan(imag / real) + π
|
||||
} else if (real < 0.0 && imag < 0.0) {
|
||||
Math.atan(imag / real) - π
|
||||
} else if (real == 0.0 && imag > 0.0) {
|
||||
π / 2.0
|
||||
} else if (real == 0.0 && imag < 0.0) {
|
||||
-π / 2.0
|
||||
} else {
|
||||
0.0
|
||||
}
|
||||
|
||||
fun exp(): Complex {
|
||||
val scale = Math.exp(real)
|
||||
Complex(scale * Math.cos(imag), scale * Math.sin(imag))
|
||||
}
|
||||
|
||||
fun ln(): Complex = Complex(Math.ln(magnitude), phase)
|
||||
|
||||
fun sin(): Complex =
|
||||
Complex(
|
||||
Math.sin(real) * Math.cosh(imag),
|
||||
Math.cos(real) * Math.sinh(imag)
|
||||
)
|
||||
|
||||
fun cos(): Complex =
|
||||
Complex(
|
||||
Math.cos(real) * Math.cosh(imag),
|
||||
-Math.sin(real) * Math.sinh(imag)
|
||||
)
|
||||
|
||||
fun tan(): Complex = sin() / cos()
|
||||
|
||||
fun sqrt(): Complex = if (imag == 0.0 && real >= 0.0) {
|
||||
Complex(Math.sqrt(real), 0.0)
|
||||
} else {
|
||||
val radius = magnitude
|
||||
val imagPart = Math.sqrt((radius - real) / 2.0)
|
||||
Complex(Math.sqrt((radius + real) / 2.0), if (imag < 0.0) -imagPart else imagPart)
|
||||
}
|
||||
|
||||
override fun toString() =
|
||||
real.toString() +
|
||||
(if (imag < 0.0) imag.toString() else "+" + imag.toString()) +
|
||||
"i"
|
||||
|
||||
static fun fromInt(value: Int): Complex = Complex(value + 0.0, 0.0)
|
||||
static fun fromReal(value: Real): Complex = Complex(value, 0.0)
|
||||
static fun imaginary(value: Real): Complex = Complex(0.0, value)
|
||||
static fun fromPolar(radius: Real, angle: Real): Complex =
|
||||
Complex(radius * Math.cos(angle), radius * Math.sin(angle))
|
||||
}
|
||||
|
||||
fun complex(re: Real, im: Real = 0.0): Complex = Complex(re, im)
|
||||
fun cis(angle: Real): Complex = Complex.fromPolar(1.0, angle)
|
||||
|
||||
val Int.re: Complex get() = Complex.fromInt(this)
|
||||
val Real.re: Complex get() = Complex.fromReal(this)
|
||||
val Int.i: Complex get() = Complex.imaginary(this + 0.0)
|
||||
val Real.i: Complex get() = Complex.imaginary(this)
|
||||
|
||||
OperatorInterop.register(
|
||||
Int,
|
||||
Complex,
|
||||
Complex,
|
||||
[BinaryOperator.Plus, BinaryOperator.Minus, BinaryOperator.Mul, BinaryOperator.Div],
|
||||
{ x: Int -> Complex.fromInt(x) },
|
||||
{ x: Complex -> x }
|
||||
)
|
||||
|
||||
OperatorInterop.register(
|
||||
Real,
|
||||
Complex,
|
||||
Complex,
|
||||
[BinaryOperator.Plus, BinaryOperator.Minus, BinaryOperator.Mul, BinaryOperator.Div],
|
||||
{ x: Real -> Complex.fromReal(x) },
|
||||
{ x: Complex -> x }
|
||||
)
|
||||
@@ -0,0 +1,157 @@
|
||||
package lyng.matrix
|
||||
|
||||
type MatrixScalar = Real | Int
|
||||
|
||||
/** Dense immutable vector backed by double-precision elements. */
|
||||
extern class Vector() {
|
||||
/** Number of elements. */
|
||||
val size: Int
|
||||
|
||||
/** Alias to `size`. */
|
||||
val length: Int
|
||||
|
||||
/** Convert to a plain list. */
|
||||
extern fun toList(): List<Real>
|
||||
|
||||
/** Get one element by zero-based index. */
|
||||
extern fun get(index: Int): Real
|
||||
|
||||
/** Element-wise addition. */
|
||||
extern fun plus(other: Vector): Vector
|
||||
|
||||
/** Element-wise subtraction. */
|
||||
extern fun minus(other: Vector): Vector
|
||||
|
||||
/** Scale every element. */
|
||||
extern fun mul(other: MatrixScalar): Vector
|
||||
|
||||
/** Divide every element by a scalar. */
|
||||
extern fun div(other: MatrixScalar): Vector
|
||||
|
||||
/** Dot product. */
|
||||
extern fun dot(other: Vector): Real
|
||||
|
||||
/** Euclidean norm. */
|
||||
extern fun norm(): Real
|
||||
|
||||
/** Return a unit-length vector in the same direction. */
|
||||
extern fun normalize(): Vector
|
||||
|
||||
/** 3D cross product. Both vectors must have length 3. */
|
||||
extern fun cross(other: Vector): Vector
|
||||
|
||||
/** Outer product, returning a matrix of shape `(this.size, other.size)`. */
|
||||
extern fun outer(other: Vector): Matrix
|
||||
|
||||
/** Build a vector from numeric values. */
|
||||
static extern fun fromList(values: List<MatrixScalar>): Vector
|
||||
|
||||
/** Zero-filled vector. */
|
||||
static extern fun zeros(size: Int): Vector
|
||||
}
|
||||
|
||||
/**
|
||||
* Dense immutable matrix backed by double-precision elements.
|
||||
*
|
||||
* `Matrix` supports arbitrary rectangular geometry (`rows x cols`), matrix arithmetic,
|
||||
* transpose, determinant, and inversion.
|
||||
*
|
||||
* Use this type for numeric linear algebra where contiguous dense storage is appropriate.
|
||||
*/
|
||||
extern class Matrix() {
|
||||
/** Number of rows. */
|
||||
val rows: Int
|
||||
|
||||
/** Number of columns. */
|
||||
val cols: Int
|
||||
|
||||
/** Two-element shape `[rows, cols]`. */
|
||||
val shape: List<Int>
|
||||
|
||||
/** Whether `rows == cols`. */
|
||||
val isSquare: Bool
|
||||
|
||||
/** Element-wise addition. Shapes must match. */
|
||||
extern fun plus(other: Matrix): Matrix
|
||||
|
||||
/** Element-wise subtraction. Shapes must match. */
|
||||
extern fun minus(other: Matrix): Matrix
|
||||
|
||||
/**
|
||||
* Multiply by another matrix, by a vector, or by a scalar.
|
||||
*
|
||||
* - `Matrix * Matrix`: matrix product (`A.cols == B.rows`)
|
||||
* - `Matrix * Vector`: matrix-vector product (`A.cols == x.size`)
|
||||
* - `Matrix * MatrixScalar`: scale every element
|
||||
*/
|
||||
extern fun mul(other: Matrix | Vector | MatrixScalar): Matrix | Vector
|
||||
|
||||
/** Divide every element by a scalar. */
|
||||
extern fun div(other: MatrixScalar): Matrix
|
||||
|
||||
/** Matrix transpose. */
|
||||
extern fun transpose(): Matrix
|
||||
|
||||
/** Sum of diagonal elements of a square matrix. */
|
||||
extern fun trace(): Real
|
||||
|
||||
/** Row rank computed numerically via row-echelon reduction. */
|
||||
extern fun rank(): Int
|
||||
|
||||
/**
|
||||
* Determinant of a square matrix.
|
||||
*
|
||||
* Raises an error for non-square matrices.
|
||||
*/
|
||||
extern fun determinant(): Real
|
||||
|
||||
/**
|
||||
* Inverse of a square matrix.
|
||||
*
|
||||
* Raises an error for non-square or singular matrices.
|
||||
*/
|
||||
extern fun inverse(): Matrix
|
||||
|
||||
/**
|
||||
* Solve `A * x = rhs`.
|
||||
*
|
||||
* - with a `Vector` right-hand side, returns a `Vector`
|
||||
* - with a `Matrix` right-hand side, returns a `Matrix`
|
||||
*/
|
||||
extern fun solve(rhs: Vector | Matrix): Vector | Matrix
|
||||
|
||||
/**
|
||||
* Bracket indexing by `[row, col]`.
|
||||
*
|
||||
* Each selector may be an `Int` or a `Range`:
|
||||
* - `m[1, 2]` returns one scalar
|
||||
* - `m[0..2, 2]` returns a `3x1` matrix
|
||||
* - `m[0..2, 0..2]` returns a sub-matrix
|
||||
* - `m[1.., 1..]` returns the bottom-right tail
|
||||
*/
|
||||
override extern fun getAt(index: List<Int | Range>): Real | Matrix
|
||||
|
||||
/** Get one element by zero-based row and column indices. */
|
||||
extern fun get(row: Int, col: Int): Real
|
||||
|
||||
/** Return one row as a `List<Real>`. */
|
||||
extern fun row(index: Int): List<Real>
|
||||
|
||||
/** Return one column as a `List<Real>`. */
|
||||
extern fun column(index: Int): List<Real>
|
||||
|
||||
/** Convert to nested row lists. */
|
||||
extern fun toList(): List<List<Real>>
|
||||
|
||||
/** Build a matrix from nested row lists. All rows must have the same length. */
|
||||
static extern fun fromRows(rows: List<List<MatrixScalar>>): Matrix
|
||||
|
||||
/** Create a zero-filled matrix. */
|
||||
static extern fun zeros(rows: Int, cols: Int): Matrix
|
||||
|
||||
/** Create an identity matrix of shape `(size, size)`. */
|
||||
static extern fun identity(size: Int): Matrix
|
||||
}
|
||||
|
||||
fun vector(values: List<MatrixScalar>): Vector = Vector.fromList(values)
|
||||
fun matrix(rows: List<List<MatrixScalar>>): Matrix = Matrix.fromRows(rows)
|
||||
@@ -77,10 +77,17 @@ extern class MapEntry<K,V> : Array<Object> {
|
||||
}
|
||||
|
||||
// Built-in math helpers (implemented in host runtime).
|
||||
extern fun abs(x: Object): Real
|
||||
extern fun ln(x: Object): Real
|
||||
extern fun pow(x: Object, y: Object): Real
|
||||
extern fun sqrt(x: Object): Real
|
||||
//
|
||||
// Decimal note:
|
||||
// - these helpers accept `BigDecimal` values too
|
||||
// - `abs`, `floor`, `ceil`, `round`, and `pow(x, y)` with integral `y` keep decimal arithmetic
|
||||
// - the remaining decimal cases currently use a temporary bridge:
|
||||
// `BigDecimal -> Real -> host math -> BigDecimal`
|
||||
// - this is temporary and will be replaced with dedicated decimal implementations
|
||||
extern fun abs(x: Object): Object
|
||||
extern fun ln(x: Object): Object
|
||||
extern fun pow(x: Object, y: Object): Object
|
||||
extern fun sqrt(x: Object): Object
|
||||
extern fun clamp<T>(value: T, range: Range<T>): T
|
||||
|
||||
class SeededRandom {
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -21,7 +21,7 @@
|
||||
|
||||
plugins {
|
||||
alias(libs.plugins.kotlinMultiplatform)
|
||||
id("org.jetbrains.kotlin.plugin.compose") version "2.2.21"
|
||||
id("org.jetbrains.kotlin.plugin.compose") version "2.3.20"
|
||||
id("org.jetbrains.compose") version "1.9.3"
|
||||
`maven-publish`
|
||||
}
|
||||
|
||||
@@ -0,0 +1,36 @@
|
||||
# Decimal Math TODO
|
||||
|
||||
These stdlib math helpers currently accept `BigDecimal`, but some still use the temporary compatibility path
|
||||
|
||||
`BigDecimal -> Real -> host math -> BigDecimal`
|
||||
|
||||
instead of a native decimal implementation.
|
||||
|
||||
## Still Using The Temporary Real Bridge
|
||||
|
||||
- `sin(x)`
|
||||
- `cos(x)`
|
||||
- `tan(x)`
|
||||
- `asin(x)`
|
||||
- `acos(x)`
|
||||
- `atan(x)`
|
||||
- `sinh(x)`
|
||||
- `cosh(x)`
|
||||
- `tanh(x)`
|
||||
- `asinh(x)`
|
||||
- `acosh(x)`
|
||||
- `atanh(x)`
|
||||
- `exp(x)`
|
||||
- `ln(x)`
|
||||
- `log10(x)`
|
||||
- `log2(x)`
|
||||
- `sqrt(x)`
|
||||
- `pow(x, y)` when the decimal case is not reducible to an integral exponent
|
||||
|
||||
## Already Native For Decimal
|
||||
|
||||
- `abs(x)`
|
||||
- `floor(x)`
|
||||
- `ceil(x)`
|
||||
- `round(x)`
|
||||
- `pow(x, y)` with integral exponent `y`
|
||||
+21
-4
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -21,8 +21,8 @@
|
||||
|
||||
plugins {
|
||||
alias(libs.plugins.kotlinMultiplatform)
|
||||
// Compose compiler plugin for Kotlin 2.2.21 (matches version catalog)
|
||||
id("org.jetbrains.kotlin.plugin.compose") version "2.2.21"
|
||||
// Compose compiler plugin aligned with the project Kotlin version.
|
||||
id("org.jetbrains.kotlin.plugin.compose") version "2.3.20"
|
||||
// Compose Multiplatform plugin for convenient dependencies (compose.html.core, etc.)
|
||||
id("org.jetbrains.compose") version "1.9.3"
|
||||
}
|
||||
@@ -117,10 +117,27 @@ val generateDocsIndex by tasks.registering {
|
||||
}
|
||||
}
|
||||
|
||||
val generateSiteVersion by tasks.registering(Copy::class) {
|
||||
group = "documentation"
|
||||
description = "Generates lyng-version.js from :lynglib version"
|
||||
|
||||
val outDir = layout.buildDirectory.dir("generated-resources")
|
||||
val versionText = project(":lynglib").version.toString()
|
||||
|
||||
inputs.property("lyngVersion", versionText)
|
||||
from(layout.projectDirectory.dir("src/version-template")) {
|
||||
include("lyng-version.js")
|
||||
filter<org.apache.tools.ant.filters.ReplaceTokens>(
|
||||
"tokens" to mapOf("LYNG_VERSION" to versionText)
|
||||
)
|
||||
}
|
||||
into(outDir)
|
||||
}
|
||||
|
||||
// Ensure any ProcessResources task depends on docs index generation so the JSON is packaged
|
||||
tasks.configureEach {
|
||||
if (name.endsWith("ProcessResources")) {
|
||||
dependsOn(generateDocsIndex)
|
||||
dependsOn(generateDocsIndex, generateSiteVersion)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -70,6 +70,7 @@ fun App() {
|
||||
|
||||
PageTemplate(title = when {
|
||||
isDocsRoute -> null
|
||||
route.startsWith("authors") -> "Authors"
|
||||
route.startsWith("reference") -> "Reference"
|
||||
route.isBlank() -> null
|
||||
else -> null
|
||||
@@ -118,6 +119,7 @@ fun App() {
|
||||
Div({ classes("col-12", if (isDocsRoute) "col-lg-9" else "col-lg-12") }) {
|
||||
when {
|
||||
route.isBlank() -> HomePage()
|
||||
route.startsWith("authors") -> AuthorsPage()
|
||||
route.startsWith("tryling") -> TryLyngPage(route)
|
||||
route.startsWith("search") -> SearchPage(route)
|
||||
!isDocsRoute -> ReferencePage()
|
||||
|
||||
@@ -0,0 +1,63 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
import androidx.compose.runtime.Composable
|
||||
import org.jetbrains.compose.web.dom.*
|
||||
|
||||
@Composable
|
||||
fun AuthorsPage() {
|
||||
Div({ classes("text-center", "mb-4") }) {
|
||||
P({
|
||||
classes("lead", "text-muted", "mb-0", "mx-auto")
|
||||
attr("style", "max-width: 42rem;")
|
||||
}) {
|
||||
Text("Designed and built with care. Special thanks to everyone around Lyng who helped shape the language, the tools, and the site into what it is now.")
|
||||
}
|
||||
}
|
||||
|
||||
Div({ classes("row", "g-4", "justify-content-center") }) {
|
||||
listOf(
|
||||
Triple(
|
||||
"Sergey Chernov",
|
||||
"Initial idea and architecture, language concept, design, implementation.",
|
||||
Pair("@sergeych", "https://www.gravatar.com/avatar/7e3a56ff8a090fc9ffbd1909dea94904?s=128&d=identicon")
|
||||
),
|
||||
Triple(
|
||||
"Yulia Nezhinskaya",
|
||||
"System analysis, math and feature design.",
|
||||
Pair("@AlterEgoJuliaN", "https://www.gravatar.com/avatar/53a90bca30c85a81db8f0c0d8dea43a1?s=128&d=identicon")
|
||||
)
|
||||
).forEach { (name, bio, profile) ->
|
||||
Div({ classes("col-12", "col-lg-5") }) {
|
||||
Div({ classes("h-100", "p-4", "border", "rounded-4", "bg-body-tertiary", "text-center") }) {
|
||||
Img(
|
||||
src = profile.second,
|
||||
alt = name,
|
||||
attrs = {
|
||||
classes("rounded-circle", "mb-3")
|
||||
attr("width", "88")
|
||||
attr("height", "88")
|
||||
}
|
||||
)
|
||||
H2({ classes("h4", "mb-1") }) { Text(name) }
|
||||
P({ classes("text-primary", "small", "mb-2") }) { Text(profile.first) }
|
||||
P({ classes("text-muted", "mb-0") }) { Text(bio) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -287,8 +287,8 @@ fun HomePage() {
|
||||
}
|
||||
}
|
||||
|
||||
// Bottom section with a small Telegram button
|
||||
Div({ classes("text-center", "mt-5", "pb-4") }) {
|
||||
// Bottom section with Telegram and authors links
|
||||
Div({ classes("text-center", "mt-5", "d-flex", "justify-content-center", "gap-2", "flex-wrap") }) {
|
||||
A(attrs = {
|
||||
classes("btn", "btn-outline-primary", "btn-sm")
|
||||
attr("href", "https://t.me/lynglang")
|
||||
@@ -298,6 +298,13 @@ fun HomePage() {
|
||||
I({ classes("bi", "bi-telegram", "me-1") })
|
||||
Text("Join our Telegram channel")
|
||||
}
|
||||
A(attrs = {
|
||||
classes("btn", "btn-outline-secondary", "btn-sm")
|
||||
attr("href", "#/authors")
|
||||
}) {
|
||||
I({ classes("bi", "bi-people", "me-1") })
|
||||
Text("Meet the authors")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -332,16 +332,22 @@
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.11.1/highlight.min.js"></script>
|
||||
<!-- and it's easy to individually load additional languages -->
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.11.1/languages/go.min.js"></script>
|
||||
<script src="lyng-version.js"></script>
|
||||
|
||||
|
||||
</head>
|
||||
<body>
|
||||
<!-- Top-left version ribbon -->
|
||||
<div class="corner-ribbon bg-danger text-white">
|
||||
<span style="margin-left: -5em">
|
||||
v1.5.1
|
||||
<span id="lyng-version-ribbon" style="margin-left: -5em">
|
||||
</span>
|
||||
</div>
|
||||
<script>
|
||||
document.addEventListener("DOMContentLoaded", function () {
|
||||
var ribbon = document.getElementById("lyng-version-ribbon");
|
||||
if (ribbon) ribbon.textContent = "v" + (window.LYNG_VERSION || "");
|
||||
});
|
||||
</script>
|
||||
<!-- Fixed top navbar for the whole site -->
|
||||
<a href="#root" class="visually-hidden-focusable position-absolute top-0 start-0 m-2 px-2 py-1 bg-body border rounded">Skip
|
||||
to content</a>
|
||||
@@ -384,6 +390,7 @@
|
||||
<!-- Will be populated at runtime -->
|
||||
<li><a class="dropdown-item" href="#/docs/tutorial.md" data-route="docs">Tutorial</a></li>
|
||||
<li><a class="dropdown-item" href="#/reference" data-route="reference">Reference</a></li>
|
||||
<li><a class="dropdown-item" href="#/authors" data-route="authors">Authors</a></li>
|
||||
<li>
|
||||
<hr class="dropdown-divider">
|
||||
</li>
|
||||
@@ -485,7 +492,7 @@
|
||||
var activeLink = null;
|
||||
if (!hash || hash === '#' || hash === '#/') {
|
||||
activeLink = document.querySelector('#topbarNav .nav-link[data-route="home"]');
|
||||
} else if (hash.startsWith('#/docs/')) {
|
||||
} else if (hash.startsWith('#/docs/') || hash.startsWith('#/authors')) {
|
||||
// Mark Docs menu root as active
|
||||
activeLink = document.querySelector('#topbarNav .nav-link.dropdown-toggle');
|
||||
} else if (hash.startsWith('#/reference')) {
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
#!/binenv lyng
|
||||
|
||||
import lyng.decimal
|
||||
|
||||
val x = "0.1".d
|
||||
val y = 0.1
|
||||
var s0 = 0.d
|
||||
var s1 = 0.0
|
||||
|
||||
for( i in 1..100 ) {
|
||||
s0 += x
|
||||
s1 += y
|
||||
}
|
||||
|
||||
println("$s0")
|
||||
println("$s1")
|
||||
|
||||
println(":: ${sin(3.14)}")
|
||||
Reference in new issue
Block a user