Compare commits

...
13 Commits
60 changed files with 3328 additions and 239 deletions

No files matched your search

+1
View File
@@ -27,3 +27,4 @@ debug.log
/compile_jvm_output.txt /compile_jvm_output.txt
/compile_metadata_output.txt /compile_metadata_output.txt
test_output*.txt test_output*.txt
/site/src/version-template/lyng-version.js
+9 -7
View File
@@ -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] site with integrated interpreter to give a try
- [x] kotlin part public API good docs, integration focused - [x] kotlin part public API good docs, integration focused
- [ ] type specifications - [x] type specifications
- [x] Textmate Bundle - [x] Textmate Bundle
- [x] IDEA plugin - [x] IDEA plugin
- [ ] source docs and maybe lyng.md to a standard - [x] source docs and maybe lyng.md to a standard
- [ ] metadata first class access from lyng
- [x] aggressive optimizations - [x] aggressive optimizations
- [ ] compile to JVM bytecode optimization
## After 1.5 "Ideal scripting" ## After 1.5 "Ideal scripting"
Estimated summer 2026 * __we are here now ;)__
- propose your feature! - 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. @-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 [parallelism]: docs/parallelism.md
-7
View File
@@ -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)
+7
View File
@@ -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 Array therefore implements [Iterable] too. Well known implementations of `Array` are
[List] and [ImmutableList]. [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: Array adds the following methods:
## Binary search ## Binary search
+82
View File
@@ -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.
+73 -9
View File
@@ -8,9 +8,9 @@ Import it when you need decimal arithmetic that should not inherit `Real`'s bina
import lyng.decimal import lyng.decimal
``` ```
## What `BigDecimal` Is For ## What `Decimal` Is For
Use `BigDecimal` when values are fundamentally decimal: Use `Decimal` when values are fundamentally decimal:
- money - money
- human-entered quantities - human-entered quantities
@@ -38,8 +38,8 @@ assertEquals("2.2", c.toStringExpanded())
The three forms mean different things: The three forms mean different things:
- `1.d`: convert `Int -> BigDecimal` - `1.d`: convert `Int -> Decimal`
- `2.2.d`: convert `Real -> BigDecimal` - `2.2.d`: convert `Real -> Decimal`
- `"2.2".d`: parse exact decimal text - `"2.2".d`: parse exact decimal text
That distinction is intentional. That distinction is intentional.
@@ -67,16 +67,36 @@ The explicit factory methods are:
```lyng ```lyng
import lyng.decimal import lyng.decimal
BigDecimal.fromInt(10) Decimal.fromInt(10)
BigDecimal.fromReal(2.5) Decimal.fromReal(2.5)
BigDecimal.fromString("12.34") Decimal.fromString("12.34")
``` ```
These are equivalent to the conversion-property forms, but sometimes clearer in APIs or generated code. These are equivalent to the conversion-property forms, but sometimes clearer in APIs or generated code.
## From Kotlin
If you already have an ionspin `BigDecimal` on the host side, the simplest supported way to create a Lyng `Decimal` is:
```kotlin
import com.ionspin.kotlin.bignum.decimal.BigDecimal
import net.sergeych.lyng.Script
import net.sergeych.lyng.asFacade
import net.sergeych.lyng.newDecimal
val scope = Script.newScope()
val decimal = scope.asFacade().newDecimal(BigDecimal.parseStringWithMode("12.34"))
```
Notes:
- `newDecimal(...)` loads `lyng.decimal` if needed
- it returns a real Lyng `Decimal` object instance
- this is the preferred Kotlin-side construction path when you already hold a host `BigDecimal`
## Core Operations ## Core Operations
`BigDecimal` supports: `Decimal` supports:
- `+` - `+`
- `-` - `-`
@@ -115,7 +135,7 @@ assert(2 == 2.d)
assert(3 > 2.d) assert(3 > 2.d)
``` ```
Without this registration mechanism, only the cases directly implemented on the left-hand class would work. The bridge fills the gap for expressions such as `Int + BigDecimal` and `Real + BigDecimal`. Without this registration mechanism, only the cases directly implemented on the left-hand class would work. The bridge fills the gap for expressions such as `Int + Decimal` and `Real + Decimal`.
See [OperatorInterop.md](OperatorInterop.md) for the generic mechanism behind that. See [OperatorInterop.md](OperatorInterop.md) for the generic mechanism behind that.
@@ -223,6 +243,50 @@ assertEquals("-0.12", withDecimalContext(2, DecimalRounding.HalfTowardsZero) { (
## Recommended Usage Rules ## 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 `Decimal`.
Current behavior is intentionally split:
- exact decimal implementation:
- `abs(x)`
- `floor(x)`
- `ceil(x)`
- `round(x)`
- `pow(x, y)` when `x` is `Decimal` 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
Decimal -> Real -> host math -> Decimal
```
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 Decimal).toStringExpanded())
assertEquals("2", (floor("2.9".d) as Decimal).toStringExpanded())
// Temporary Real bridge:
assertEquals((exp(1.25) as Real).d.toStringExpanded(), (exp("1.25".d) as Decimal).toStringExpanded())
assertEquals((sqrt(2.0) as Real).d.toStringExpanded(), (sqrt("2".d) as Decimal).toStringExpanded())
```
If you care about exact decimal source text: If you care about exact decimal source text:
```lyng ```lyng
+7
View File
@@ -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. __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 ## Concatenation
You can concatenate lists or iterable objects: You can concatenate lists or iterable objects:
+192
View File
@@ -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
View File
@@ -1183,8 +1183,24 @@ collection's sugar won't work with it:
assertEquals("buzz", x[0]) assertEquals("buzz", x[0])
>>> void >>> void
If you want dynamic to function like an array, create a [feature Multiple selectors are packed into one list index object:
request](https://gitea.sergeych.net/SergeychWorks/lyng/issues).
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 # Theory
+5 -5
View File
@@ -160,15 +160,15 @@ import lyng.decimal
3 > 2.d 3 > 2.d
``` ```
work naturally even though `Int` and `Real` themselves were not edited to know `BigDecimal`. work naturally even though `Int` and `Real` themselves were not edited to know `Decimal`.
The shape is: The shape is:
- `leftClass = Int` or `Real` - `leftClass = Int` or `Real`
- `rightClass = BigDecimal` - `rightClass = Decimal`
- `commonClass = BigDecimal` - `commonClass = Decimal`
- convert built-ins into `BigDecimal` - convert built-ins into `Decimal`
- leave `BigDecimal` values unchanged - leave `Decimal` values unchanged
## Step-By-Step Pattern For Your Own Type ## Step-By-Step Pattern For Your Own Type
+6 -1
View File
@@ -82,11 +82,16 @@ Primary sources used: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/{Parser,T
- Type/containment: `is`, `!is`, `in`, `!in`, `as`, `as?`. - Type/containment: `is`, `!is`, `in`, `!in`, `as`, `as?`.
- Null-safe family: - Null-safe family:
- member access: `?.` - member access: `?.`
- safe index: `?[i]` - safe index: `?[i]`, `?[i, j]`
- safe invoke: `?(...)` - safe invoke: `?(...)`
- safe block invoke: `?{ ... }` - safe block invoke: `?{ ... }`
- elvis: `?:` and `??`. - elvis: `?:` and `??`.
- Increment/decrement: prefix and postfix `++`, `--`. - 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 ## 5. Declarations
- Variables: - Variables:
+11
View File
@@ -15,6 +15,10 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
- Preconditions: `require`, `check`. - Preconditions: `require`, `check`.
- Async/concurrency: `launch`, `yield`, `flow`, `delay`. - 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`. - 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.Decimal`.
- Exact Decimal path today: `abs`, `floor`, `ceil`, `round`, and `pow` with integral exponent.
- Temporary Decimal path for the rest: convert `Decimal -> Real`, compute, then convert back to `Decimal`.
- Treat that bridge as temporary; prefer native Decimal implementations when they become available.
## 3. Core Global Constants/Types ## 3. Core Global Constants/Types
- Values: `Unset`, `π`. - Values: `Unset`, `π`.
@@ -56,6 +60,13 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
## 5. Additional Built-in Modules (import explicitly) ## 5. Additional Built-in Modules (import explicitly)
- `import lyng.observable` - `import lyng.observable`
- `Observable`, `Subscription`, `ObservableList`, `ListChange` and change subtypes, `ChangeRejectionException`. - `Observable`, `Subscription`, `ObservableList`, `ListChange` and change subtypes, `ChangeRejectionException`.
- `import lyng.decimal`
- `Decimal`, `DecimalContext`, `DecimalRounding`, `withDecimalContext(...)`.
- Kotlin host helper: `ScopeFacade.newDecimal(BigDecimal)` wraps an ionspin host decimal as a Lyng `Decimal`.
- `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` - `import lyng.buffer`
- `Buffer`, `MutableBuffer`. - `Buffer`, `MutableBuffer`.
- `import lyng.serialization` - `import lyng.serialization`
+66
View File
@@ -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. 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 ### 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. 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
View File
@@ -60,8 +60,13 @@ but:
## Round and range ## Round and range
The following functions return its argument if it is `Int`, The following functions return the argument unchanged if it is `Int`.
or transformed `Real` otherwise.
For `Decimal`:
- `floor(x)`, `ceil(x)`, and `round(x)` currently use exact decimal operations
- the result stays `Decimal`
For `Real`, the result is a transformed `Real`.
| name | description | | name | description |
|----------------|--------------------------------------------------------| |----------------|--------------------------------------------------------|
@@ -72,6 +77,14 @@ or transformed `Real` otherwise.
## Lyng math functions ## Lyng math functions
Decimal note:
- all scalar math helpers accept `Decimal`
- `abs(x)` stays exact for `Decimal`
- `pow(x, y)` is exact for `Decimal` when `y` is an integral exponent
- the remaining `Decimal` cases currently use a temporary bridge:
`Decimal -> Real -> host math -> Decimal`
- this is temporary; native decimal implementations are planned
| name | meaning | | name | meaning |
|-----------|------------------------------------------------------| |-----------|------------------------------------------------------|
| sin(x) | sine | | sin(x) | sine |
@@ -91,7 +104,7 @@ or transformed `Real` otherwise.
| log10(x) | $log_{10}(x)$ | | log10(x) | $log_{10}(x)$ |
| pow(x, y) | ${x^y}$ | | pow(x, y) | ${x^y}$ |
| sqrt(x) | $ \sqrt {x}$ | | 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, Decimal if x is Decimal, Real otherwise |
| clamp(x, range) | limit x to be inside range boundaries | | clamp(x, range) | limit x to be inside range boundaries |
For example: For example:
@@ -104,12 +117,69 @@ For example:
assert( abs(-1) is Int) assert( abs(-1) is Int)
assert( abs(-2.21) == 2.21 ) 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 Decimal).toStringExpanded() == "2.5" )
assert( (floor("2.9".d) as Decimal).toStringExpanded() == "2" )
assert( sin("0.5".d) is Decimal )
// clamp() limits value to the range: // clamp() limits value to the range:
assert( clamp(15, 0..10) == 10 ) assert( clamp(15, 0..10) == 10 )
assert( clamp(-5, 0..10) == 0 ) assert( clamp(-5, 0..10) == 0 )
assert( 5.clamp(0..10) == 5 ) assert( 5.clamp(0..10) == 5 )
>>> void >>> 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 ## Random values
Lyng stdlib provides a global random singleton and deterministic seeded generators: Lyng stdlib provides a global random singleton and deterministic seeded generators:
+28
View File
@@ -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. 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 Logical operation could be used the same
var x = 10 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). 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: When you want to "flatten" it to single array, you can use splat syntax:
[1, ...[2,3], 4] [1, ...[2,3], 4]
@@ -1699,6 +1719,14 @@ Open-ended ranges could be used to get start and end too:
assertEquals( "pult", "catapult"[ 4.. ]) assertEquals( "pult", "catapult"[ 4.. ])
>>> void >>> 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 ### String operations
Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also
+48 -1
View File
@@ -5,12 +5,59 @@ For a programmer-focused migration summary, see `docs/whats_new_1_5.md`.
## Language Features ## 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`) ### 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. Lyng now ships a first-class decimal module built as a regular extension library rather than a deep core special case.
It provides: It provides:
- `BigDecimal` - `Decimal`
- convenient `.d` conversions from `Int`, `Real`, and `String` - convenient `.d` conversions from `Int`, `Real`, and `String`
- mixed arithmetic with `Int` and `Real` - mixed arithmetic with `Int` and `Real`
- local division precision and rounding control via `withDecimalContext(...)` - local division precision and rounding control via `withDecimalContext(...)`
+1 -4
View File
@@ -27,9 +27,6 @@ kotlin.mpp.enableCInteropCommonization=true
android.useAndroidX=true android.useAndroidX=true
android.nonTransitiveRClass=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. # 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 # On this environment, the system JDK 21 installation lacks `jlink`, causing
# :lynglib:androidJdkImage to fail. Point Gradle to a JDK that includes `jlink`. # :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 #org.gradle.java.home=/home/sergeych/.jdks/corretto-21.0.9
android.experimental.lint.migrateToK2=false android.experimental.lint.migrateToK2=false
android.lint.useK2Uast=false android.lint.useK2Uast=false
kotlin.mpp.applyDefaultHierarchyTemplate=true kotlin.mpp.applyDefaultHierarchyTemplate=false
org.gradle.parallel=true org.gradle.parallel=true
+3 -1
View File
@@ -2,13 +2,14 @@
agp = "8.5.2" agp = "8.5.2"
clikt = "5.0.3" clikt = "5.0.3"
mordant = "3.0.2" mordant = "3.0.2"
kotlin = "2.3.0" kotlin = "2.3.20"
android-minSdk = "24" android-minSdk = "24"
android-compileSdk = "34" android-compileSdk = "34"
kotlinx-coroutines = "1.10.2" kotlinx-coroutines = "1.10.2"
kotlinx-datetime = "0.6.1" kotlinx-datetime = "0.6.1"
mp_bintools = "0.3.2" mp_bintools = "0.3.2"
ionspin-bignum = "0.3.10" ionspin-bignum = "0.3.10"
multik = "0.3.0"
firebaseCrashlyticsBuildtools = "3.0.3" firebaseCrashlyticsBuildtools = "3.0.3"
okioVersion = "3.10.2" okioVersion = "3.10.2"
compiler = "3.2.0-alpha11" 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" } kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }
mp_bintools = { module = "net.sergeych:mp_bintools", version.ref = "mp_bintools" } mp_bintools = { module = "net.sergeych:mp_bintools", version.ref = "mp_bintools" }
ionspin-bignum = { module = "com.ionspin.kotlin:bignum", version.ref = "ionspin-bignum" } 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" } firebase-crashlytics-buildtools = { group = "com.google.firebase", name = "firebase-crashlytics-buildtools", version.ref = "firebaseCrashlyticsBuildtools" }
okio = { module = "com.squareup.okio:okio", version.ref = "okioVersion" } okio = { module = "com.squareup.okio:okio", version.ref = "okioVersion" }
okio-fakefilesystem = { module = "com.squareup.okio:okio-fakefilesystem", 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.AnAction
import com.intellij.openapi.actionSystem.AnActionEvent import com.intellij.openapi.actionSystem.AnActionEvent
import com.intellij.openapi.actionSystem.CommonDataKeys 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.project.Project
import com.intellij.openapi.wm.ToolWindow import com.intellij.openapi.wm.ToolWindow
import com.intellij.openapi.wm.ToolWindowAnchor import com.intellij.openapi.wm.ToolWindowAnchor
@@ -36,9 +38,10 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.launch import kotlinx.coroutines.launch
import net.sergeych.lyng.idea.LyngIcons import net.sergeych.lyng.idea.LyngIcons
import java.io.File
class RunLyngScriptAction : AnAction(LyngIcons.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? { private fun getPsiFile(e: AnActionEvent): PsiFile? {
val project = e.project ?: return null 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) { override fun update(e: AnActionEvent) {
val psiFile = getPsiFile(e) val psiFile = getRunnableFile(e)
val isLyng = psiFile?.name?.endsWith(".lyng") == true val isRunnable = psiFile != null
e.presentation.isEnabledAndVisible = isLyng e.presentation.isEnabledAndVisible = isRunnable
if (isLyng) { if (isRunnable) {
e.presentation.isEnabled = false e.presentation.text = "Run '${psiFile.name}'"
e.presentation.text = "Run '${psiFile.name}' (disabled)" e.presentation.description = "Run the current Lyng script using the Lyng CLI"
e.presentation.description = "Running scripts from the IDE is disabled; use the CLI."
} else { } else {
e.presentation.text = "Run Lyng Script" e.presentation.text = "Run Lyng Script"
e.presentation.description = "Run the current Lyng script"
} }
} }
override fun actionPerformed(e: AnActionEvent) { override fun actionPerformed(e: AnActionEvent) {
val project = e.project ?: return val project = e.project ?: return
val psiFile = getPsiFile(e) ?: return val psiFile = getRunnableFile(e) ?: return
val fileName = psiFile.name 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) val (console, toolWindow) = getConsoleAndToolWindow(project)
console.clear() console.clear()
toolWindow.show { toolWindow.show {
scope.launch { scope.launch {
console.print("--- Run is disabled ---\n", ConsoleViewContentType.SYSTEM_OUTPUT) val command = startLyngProcess(filePath, workingDir)
console.print("Lyng now runs in bytecode-only mode; the IDE no longer evaluates scripts.\n", ConsoleViewContentType.NORMAL_OUTPUT) if (command == null) {
console.print("Use the CLI to run scripts, e.g. `lyng run $fileName`.\n", ConsoleViewContentType.NORMAL_OUTPUT) 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> { private fun getConsoleAndToolWindow(project: Project): Pair<ConsoleView, ToolWindow> {
val toolWindowManager = ToolWindowManager.getInstance(project) val toolWindowManager = ToolWindowManager.getInstance(project)
var toolWindow = toolWindowManager.getToolWindow(ToolWindowId.RUN) var toolWindow = toolWindowManager.getToolWindow(ToolWindowId.RUN)
@@ -106,4 +172,10 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
contentManager.setSelectedContent(content) contentManager.setSelectedContent(content)
return console to actualToolWindow return console to actualToolWindow
} }
private data class StartedProcess(
val process: Process,
val commandLine: String,
val workingDir: String
)
} }
+8 -8
View File
@@ -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"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -34,11 +34,13 @@ kotlin {
// Suppress Beta warning for expect/actual classes across all targets in this module // Suppress Beta warning for expect/actual classes across all targets in this module
targets.configureEach { targets.configureEach {
compilations.configureEach { compilations.configureEach {
compilerOptions.configure { compileTaskProvider.configure {
compilerOptions {
freeCompilerArgs.add("-Xexpect-actual-classes") freeCompilerArgs.add("-Xexpect-actual-classes")
} }
} }
} }
}
jvm { jvm {
binaries { binaries {
@@ -75,19 +77,17 @@ kotlin {
implementation(libs.okio.fakefilesystem) implementation(libs.okio.fakefilesystem)
} }
} }
val nativeMain by creating {
dependsOn(commonMain)
}
val jvmTest by getting { val jvmTest by getting {
dependencies { dependencies {
implementation(kotlin("test")) implementation(kotlin("test"))
implementation(kotlin("test-junit")) implementation(kotlin("test-junit"))
} }
} }
// val nativeMain by getting {
// dependencies {
// implementation(kotlin("stdlib-common"))
// }
// }
val linuxX64Main by getting { val linuxX64Main by getting {
dependsOn(nativeMain)
} }
} }
} }
+25 -2
View File
@@ -44,7 +44,6 @@ kotlin {
iosX64() iosX64()
iosArm64() iosArm64()
iosSimulatorArm64() iosSimulatorArm64()
macosX64()
macosArm64() macosArm64()
mingwX64() mingwX64()
linuxX64() linuxX64()
@@ -62,11 +61,13 @@ kotlin {
// Keep expect/actual warning suppressed consistently with other modules // Keep expect/actual warning suppressed consistently with other modules
targets.configureEach { targets.configureEach {
compilations.configureEach { compilations.configureEach {
compilerOptions.configure { compileTaskProvider.configure {
compilerOptions {
freeCompilerArgs.add("-Xexpect-actual-classes") freeCompilerArgs.add("-Xexpect-actual-classes")
} }
} }
} }
}
sourceSets { sourceSets {
all { all {
@@ -81,11 +82,33 @@ kotlin {
api(libs.mordant.core) 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 { val commonTest by getting {
dependencies { dependencies {
implementation(libs.kotlin.test) 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 // JS: use runtime detection in jsMain to select Node vs Browser implementation
val jsMain by getting { val jsMain by getting {
+70 -17
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
import org.jetbrains.kotlin.gradle.dsl.JvmTarget import org.jetbrains.kotlin.gradle.dsl.JvmTarget
group = "net.sergeych" 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 // 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.kotlinMultiplatform)
alias(libs.plugins.androidLibrary) alias(libs.plugins.androidLibrary)
// alias(libs.plugins.vanniktech.mavenPublish) // 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" id("com.codingfeline.buildkonfig") version "0.17.1"
`maven-publish` `maven-publish`
} }
@@ -58,7 +58,6 @@ kotlin {
iosX64() iosX64()
iosArm64() iosArm64()
iosSimulatorArm64() iosSimulatorArm64()
macosX64()
macosArm64() macosArm64()
mingwX64() mingwX64()
linuxX64() linuxX64()
@@ -76,11 +75,13 @@ kotlin {
// Suppress Beta warning for expect/actual classes across all targets // Suppress Beta warning for expect/actual classes across all targets
targets.configureEach { targets.configureEach {
compilations.configureEach { compilations.configureEach {
compilerOptions.configure { compileTaskProvider.configure {
compilerOptions {
freeCompilerArgs.add("-Xexpect-actual-classes") freeCompilerArgs.add("-Xexpect-actual-classes")
} }
} }
} }
}
sourceSets { sourceSets {
all { all {
@@ -94,7 +95,7 @@ kotlin {
} }
val commonMain by getting { val commonMain by getting {
kotlin.srcDir("$buildDir/generated/buildConfig/commonMain/kotlin") kotlin.srcDir(layout.buildDirectory.dir("generated/buildConfig/commonMain/kotlin"))
dependencies { dependencies {
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0") implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0")
implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1") implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1")
@@ -110,6 +111,51 @@ kotlin {
implementation(libs.kotlinx.coroutines.test) 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 { val jvmTest by getting {
dependencies { dependencies {
// Allow tests to load external docs like lyng.io.fs via registrar // 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 outBase = outputDir.get().asFile
val targetDir = outBase.resolve(pkgPath) val targetDir = outBase.resolve(pkgPath)
targetDir.mkdirs() targetDir.mkdirs()
targetDir.listFiles()
?.filter { it.isFile && it.name.endsWith(".generated.kt") }
?.forEach { it.delete() }
val srcDir = sourceDir.get().asFile val srcDir = sourceDir.get().asFile
val files = srcDir.walkTopDown() val files = srcDir.walkTopDown()
@@ -156,34 +205,38 @@ abstract class GenerateLyngStdlib : DefaultTask() {
.sortedBy { it.name } .sortedBy { it.name }
.toList() .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 { fun escapeForQuoted(s: String): String = buildString {
for (ch in s) when (ch) { for (ch in s) when (ch) {
'\\' -> append("\\\\") '\\' -> append("\\\\")
'"' -> append("\\\"") '"' -> append("\\\"")
'$' -> append("\\$")
'\n' -> append("\\n") '\n' -> append("\\n")
'\r' -> {} '\r' -> {}
'\t' -> append("\\t") '\t' -> append("\\t")
else -> append(ch) else -> append(ch)
} }
} }
val body = escapeForQuoted(content)
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"
}
for (file in files) {
val body = escapeForQuoted(file.readText())
val sb = StringBuilder() val sb = StringBuilder()
sb.append("package ").append(targetPkg).append("\n\n") sb.append("package ").append(targetPkg).append("\n\n")
sb.append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n") sb.append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n")
sb.append("internal val rootLyng = \"") sb.append("internal val ").append(constantName(file.nameWithoutExtension)).append(" = \"")
sb.append(body) sb.append(body)
sb.append("\"\n") sb.append("\"\n")
targetDir.resolve("${file.nameWithoutExtension}_lyng.generated.kt").writeText(sb.toString())
targetDir.resolve("root_lyng.generated.kt").writeText(sb.toString()) }
} }
} }
@@ -2915,9 +2915,9 @@ class Compiler(
operand?.let { left -> operand?.let { left ->
// array access via ObjRef // array access via ObjRef
val isOptional = t.type == Token.Type.NULL_COALESCE_INDEX 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") 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 { } ?: run {
// array literal // array literal
val entries = parseArrayLiteral() 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> { private suspend fun parseDestructuringPattern(): List<ListEntry> {
// it should be called after Token.Type.LBRACKET is consumed // it should be called after Token.Type.LBRACKET is consumed
val entries = mutableListOf<ListEntry>() val entries = mutableListOf<ListEntry>()
@@ -8253,7 +8267,7 @@ class Compiler(
?: context.parent?.get(localName) ?: context.parent?.get(localName)
?: context.get(localName) ?: context.get(localName)
?: continue ?: 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) context.resolve(record, localName)
} else { } else {
record.value 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 { override suspend fun callOn(scope: Scope): Obj {
val resolved = read() val resolved = read()
if (resolved === this) { if (resolved === this) {
@@ -193,4 +206,18 @@ class RecordSlotRef(
record.value = value 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
}
} }
@@ -17,6 +17,7 @@
package net.sergeych.lyng package net.sergeych.lyng
import com.ionspin.kotlin.bignum.decimal.BigDecimal
import net.sergeych.lyng.obj.* import net.sergeych.lyng.obj.*
/** /**
@@ -133,3 +134,6 @@ fun ScopeFacade.raiseIllegalOperation(message: String = "Operation is illegal"):
fun ScopeFacade.raiseIterationFinished(): Nothing = fun ScopeFacade.raiseIterationFinished(): Nothing =
raiseError(ObjIterationFinishedException(requireScope())) raiseError(ObjIterationFinishedException(requireScope()))
suspend fun ScopeFacade.newDecimal(value: BigDecimal): ObjInstance =
ObjDecimalSupport.newDecimal(this, value)
@@ -27,7 +27,9 @@ import net.sergeych.lyng.bytecode.CmdVm
import net.sergeych.lyng.miniast.* import net.sergeych.lyng.miniast.*
import net.sergeych.lyng.obj.* import net.sergeych.lyng.obj.*
import net.sergeych.lyng.pacman.ImportManager 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.decimalLyng
import net.sergeych.lyng.stdlib_included.matrixLyng
import net.sergeych.lyng.stdlib_included.observableLyng import net.sergeych.lyng.stdlib_included.observableLyng
import net.sergeych.lyng.stdlib_included.operatorsLyng import net.sergeych.lyng.stdlib_included.operatorsLyng
import net.sergeych.lyng.stdlib_included.rootLyng import net.sergeych.lyng.stdlib_included.rootLyng
@@ -250,6 +252,44 @@ class Script(
companion object { companion object {
private suspend fun ScopeFacade.numberToDouble(value: Obj): Double =
ObjDecimalSupport.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 (ObjDecimalSupport.isDecimalValue(value)) {
return ObjDecimalSupport.fromRealLike(this, value, fallback(numberToDouble(value)))
?: raiseIllegalState("failed to convert Real result back to Decimal")
}
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 {
ObjDecimalSupport.exactPow(this, base, exponent)?.let { return it }
if (ObjDecimalSupport.isDecimalValue(base) || ObjDecimalSupport.isDecimalValue(exponent)) {
return ObjDecimalSupport.fromRealLike(this, base, numberToDouble(base).pow(numberToDouble(exponent)))
?: ObjDecimalSupport.fromRealLike(this, exponent, numberToDouble(base).pow(numberToDouble(exponent)))
?: raiseIllegalState("failed to convert Real pow result back to Decimal")
}
return ObjReal(numberToDouble(base).pow(numberToDouble(exponent)))
}
/** /**
* Create new scope using a standard safe set of modules, using [defaultImportManager]. It is * 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 * suspended as first time invocation requires compilation of standard library or other
@@ -287,87 +327,81 @@ class Script(
} }
addFn("floor") { addFn("floor") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
(if (x is ObjInt) x decimalAwareRoundLike(x, ObjDecimalSupport::exactFloor, ::floor)
else ObjReal(floor(x.toDouble())))
} }
addFn("ceil") { addFn("ceil") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
(if (x is ObjInt) x decimalAwareRoundLike(x, ObjDecimalSupport::exactCeil, ::ceil)
else ObjReal(ceil(x.toDouble())))
} }
addFn("round") { addFn("round") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
(if (x is ObjInt) x decimalAwareRoundLike(x, ObjDecimalSupport::exactRound, ::round)
else ObjReal(round(x.toDouble())))
} }
addFn("sin") { addFn("sin") {
ObjReal(sin(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sin)
} }
addFn("cos") { addFn("cos") {
ObjReal(cos(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cos)
} }
addFn("tan") { addFn("tan") {
ObjReal(tan(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tan)
} }
addFn("asin") { addFn("asin") {
ObjReal(asin(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asin)
} }
addFn("acos") { addFn("acos") {
ObjReal(acos(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acos)
} }
addFn("atan") { addFn("atan") {
ObjReal(atan(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atan)
} }
addFn("sinh") { addFn("sinh") {
ObjReal(sinh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sinh)
} }
addFn("cosh") { addFn("cosh") {
ObjReal(cosh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cosh)
} }
addFn("tanh") { addFn("tanh") {
ObjReal(tanh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tanh)
} }
addFn("asinh") { addFn("asinh") {
ObjReal(asinh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asinh)
} }
addFn("acosh") { addFn("acosh") {
ObjReal(acosh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acosh)
} }
addFn("atanh") { addFn("atanh") {
ObjReal(atanh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atanh)
} }
addFn("exp") { addFn("exp") {
ObjReal(exp(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::exp)
} }
addFn("ln") { addFn("ln") {
ObjReal(ln(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::ln)
} }
addFn("log10") { addFn("log10") {
ObjReal(log10(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log10)
} }
addFn("log2") { addFn("log2") {
ObjReal(log2(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log2)
} }
addFn("pow") { addFn("pow") {
requireExactCount(2) requireExactCount(2)
ObjReal( decimalAwarePow(args[0], args[1])
(args[0].toDouble()).pow(args[1].toDouble())
)
} }
addFn("sqrt") { addFn("sqrt") {
ObjReal( decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sqrt)
sqrt(args.firstAndOnly().toDouble())
)
} }
addFn("abs") { addFn("abs") {
val x = args.firstAndOnly() 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, ObjDecimalSupport::exactAbs) { it.absoluteValue }
} }
addFnDoc( addFnDoc(
@@ -615,12 +649,88 @@ class Script(
type = type("lyng.Real") type = type("lyng.Real")
) )
getOrCreateNamespace("Math").apply { getOrCreateNamespace("Math").apply {
fun ensureFn(name: String, fn: suspend ScopeFacade.() -> Obj) {
if (members.containsKey(name)) return
addFn(name, code = fn)
}
addConstDoc( addConstDoc(
name = "PI", name = "PI",
value = pi, value = pi,
doc = "The mathematical constant pi (π) in the Math namespace.", doc = "The mathematical constant pi (π) in the Math namespace.",
type = type("lyng.Real") type = type("lyng.Real")
) )
ensureFn("floor") {
val x = args.firstAndOnly()
decimalAwareRoundLike(x, ObjDecimalSupport::exactFloor, ::floor)
}
ensureFn("ceil") {
val x = args.firstAndOnly()
decimalAwareRoundLike(x, ObjDecimalSupport::exactCeil, ::ceil)
}
ensureFn("round") {
val x = args.firstAndOnly()
decimalAwareRoundLike(x, ObjDecimalSupport::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, ObjDecimalSupport::exactAbs) { it.absoluteValue }
}
} }
} }
@@ -757,7 +867,14 @@ class Script(
} }
addPackage("lyng.decimal") { module -> addPackage("lyng.decimal") { module ->
module.eval(Source("lyng.decimal", decimalLyng)) module.eval(Source("lyng.decimal", decimalLyng))
ObjBigDecimalSupport.bindTo(module) ObjDecimalSupport.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") { addPackage("lyng.buffer") {
it.addConstDoc( it.addConstDoc(
@@ -2396,7 +2396,8 @@ class BytecodeCompiler(
builder.emit(Opcode.THROW, posId, msgSlot) builder.emit(Opcode.THROW, posId, msgSlot)
return value return value
} }
val slot = resolveSlot(localTarget) val slot = resolveCapturedOwnerScopeSlot(localTarget)
?: resolveSlot(localTarget)
?: resolveAssignableSlotByName(localTarget.name)?.first ?: resolveAssignableSlotByName(localTarget.name)?.first
?: return null ?: return null
if (slot < scopeSlotCount && value.type != SlotType.UNKNOWN) { if (slot < scopeSlotCount && value.type != SlotType.UNKNOWN) {
@@ -2702,7 +2703,7 @@ class BytecodeCompiler(
return CompiledValue(result, SlotType.OBJ) return CompiledValue(result, SlotType.OBJ)
} }
if (localTarget.isDelegated) return compileEvalRef(ref) 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 val targetType = slotTypes[slot] ?: SlotType.OBJ
if (!localTarget.isMutable) { if (!localTarget.isMutable) {
if (targetType != SlotType.OBJ && targetType != SlotType.UNKNOWN) return compileEvalRef(ref) if (targetType != SlotType.OBJ && targetType != SlotType.UNKNOWN) return compileEvalRef(ref)
@@ -7630,6 +7631,13 @@ class BytecodeCompiler(
return scopeSlotMap[scopeKey] 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) { private fun updateSlotType(slot: Int, type: SlotType) {
if (forcedObjSlots.contains(slot) && type != SlotType.OBJ) return if (forcedObjSlots.contains(slot) && type != SlotType.OBJ) return
if (type == SlotType.UNKNOWN) { if (type == SlotType.UNKNOWN) {
@@ -50,7 +50,7 @@ class BytecodeStatement private constructor(
?: scope.parent?.get(name) ?: scope.parent?.get(name)
?: scope.get(name) ?: scope.get(name)
?: continue ?: 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) scope.resolve(record, name)
} else { } else {
record.value record.value
@@ -85,6 +85,9 @@ class CmdNop : Cmd() {
class CmdMoveObj(internal val src: Int, internal val dst: Int) : Cmd() { class CmdMoveObj(internal val src: Int, internal val dst: Int) : Cmd() {
override suspend fun perform(frame: CmdFrame) { override suspend fun perform(frame: CmdFrame) {
val value = frame.slotToObj(src) val value = frame.slotToObj(src)
if (frame.writeThroughPropertyLikeSlot(dst, value)) {
return
}
if (frame.shouldBypassImmutableWrite(dst)) { if (frame.shouldBypassImmutableWrite(dst)) {
frame.setObjUnchecked(dst, value) frame.setObjUnchecked(dst, value)
} else { } 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() { class CmdMoveInt(internal val src: Int, internal val dst: Int) : Cmd() {
override suspend fun perform(frame: CmdFrame) { override suspend fun perform(frame: CmdFrame) {
val value = frame.getInt(src) val value = frame.getInt(src)
if (frame.writeThroughPropertyLikeSlot(dst, ObjInt.of(value))) {
return
}
if (frame.shouldBypassImmutableWrite(dst)) { if (frame.shouldBypassImmutableWrite(dst)) {
frame.setIntUnchecked(dst, value) frame.setIntUnchecked(dst, value)
} else { } 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() { class CmdMoveReal(internal val src: Int, internal val dst: Int) : Cmd() {
override suspend fun perform(frame: CmdFrame) { override suspend fun perform(frame: CmdFrame) {
val value = frame.getReal(src) val value = frame.getReal(src)
if (frame.writeThroughPropertyLikeSlot(dst, ObjReal.of(value))) {
return
}
if (frame.shouldBypassImmutableWrite(dst)) { if (frame.shouldBypassImmutableWrite(dst)) {
frame.setRealUnchecked(dst, value) frame.setRealUnchecked(dst, value)
} else { } 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() { class CmdMoveBool(internal val src: Int, internal val dst: Int) : Cmd() {
override suspend fun perform(frame: CmdFrame) { override suspend fun perform(frame: CmdFrame) {
val value = frame.getBool(src) val value = frame.getBool(src)
if (frame.writeThroughPropertyLikeSlot(dst, if (value) ObjTrue else ObjFalse)) {
return
}
if (frame.shouldBypassImmutableWrite(dst)) { if (frame.shouldBypassImmutableWrite(dst)) {
frame.setBoolUnchecked(dst, value) frame.setBoolUnchecked(dst, value)
} else { } 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) val scoped = frame.scope.chainLookupIgnoreClosure(name, followClosure = true) ?: frame.scope.get(name)
if (scoped != null) { if (scoped != null) {
records += ObjRecord(RecordSlotRef(scoped), isMutable = scoped.isMutable) records += scoped
continue continue
} }
frame.ensureScope().raiseSymbolNotFound("capture $name not found") 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 val decl = frame.fn.constants[constId] as? BytecodeConst.InstancePropertyDecl
?: error("DECL_INSTANCE_PROPERTY expects InstancePropertyDecl at $constId") ?: error("DECL_INSTANCE_PROPERTY expects InstancePropertyDecl at $constId")
val scope = frame.ensureScope() val scope = frame.ensureScope()
val prop = frame.slotToObj(slot) val prop = frame.storedSlotObj(slot)
scope.addItem( scope.addItem(
decl.name, decl.name,
decl.isMutable, decl.isMutable,
@@ -3724,7 +3736,7 @@ class BytecodeLambdaCallable(
?: context.parent?.get(name) ?: context.parent?.get(name)
?: context.get(name) ?: context.get(name)
?: continue ?: 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) context.resolve(record, name)
} else { } else {
record.value record.value
@@ -3817,7 +3829,29 @@ class CmdFrame(
} }
internal fun getLocalSlotTypeCode(localIndex: Int): Byte = frame.getSlotTypeCode(localIndex) 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 { internal fun isFastLocalSlot(slot: Int): Boolean {
if (slot < fn.scopeSlotCount) return false if (slot < fn.scopeSlotCount) return false
val localIndex = slot - fn.scopeSlotCount val localIndex = slot - fn.scopeSlotCount
@@ -4262,7 +4296,7 @@ class CmdFrame(
return if (slot < fn.scopeSlotCount) { return if (slot < fn.scopeSlotCount) {
getScopeSlotValue(slot) getScopeSlotValue(slot)
} else { } 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 { suspend fun getInt(slot: Int): Long {
return if (slot < fn.scopeSlotCount) { return if (slot < fn.scopeSlotCount) {
getScopeSlotValue(slot).toLong() getScopeSlotValue(slot).toLong()
@@ -4314,14 +4377,7 @@ class CmdFrame(
SlotType.INT.code -> frame.getInt(local) SlotType.INT.code -> frame.getInt(local)
SlotType.REAL.code -> frame.getReal(local).toLong() SlotType.REAL.code -> frame.getReal(local).toLong()
SlotType.BOOL.code -> if (frame.getBool(local)) 1L else 0L SlotType.BOOL.code -> if (frame.getBool(local)) 1L else 0L
SlotType.OBJ.code -> { SlotType.OBJ.code -> readLocalSlotValue(local).toLong()
val obj = frame.getObj(local)
when (obj) {
is FrameSlotRef -> obj.read().toLong()
is RecordSlotRef -> obj.read().toLong()
else -> obj.toLong()
}
}
else -> 0L else -> 0L
} }
} }
@@ -4401,14 +4457,7 @@ class CmdFrame(
SlotType.REAL.code -> frame.getReal(local) SlotType.REAL.code -> frame.getReal(local)
SlotType.INT.code -> frame.getInt(local).toDouble() SlotType.INT.code -> frame.getInt(local).toDouble()
SlotType.BOOL.code -> if (frame.getBool(local)) 1.0 else 0.0 SlotType.BOOL.code -> if (frame.getBool(local)) 1.0 else 0.0
SlotType.OBJ.code -> { SlotType.OBJ.code -> readLocalSlotValue(local).toDouble()
val obj = frame.getObj(local)
when (obj) {
is FrameSlotRef -> obj.read().toDouble()
is RecordSlotRef -> obj.read().toDouble()
else -> obj.toDouble()
}
}
else -> 0.0 else -> 0.0
} }
} }
@@ -4477,14 +4526,7 @@ class CmdFrame(
SlotType.BOOL.code -> frame.getBool(local) SlotType.BOOL.code -> frame.getBool(local)
SlotType.INT.code -> frame.getInt(local) != 0L SlotType.INT.code -> frame.getInt(local) != 0L
SlotType.REAL.code -> frame.getReal(local) != 0.0 SlotType.REAL.code -> frame.getReal(local) != 0.0
SlotType.OBJ.code -> { SlotType.OBJ.code -> readLocalSlotValue(local).toBool()
val obj = frame.getObj(local)
when (obj) {
is FrameSlotRef -> obj.read().toBool()
is RecordSlotRef -> obj.read().toBool()
else -> obj.toBool()
}
}
else -> false else -> false
} }
} }
@@ -4596,21 +4638,42 @@ class CmdFrame(
} }
val local = slot - fn.scopeSlotCount val local = slot - fn.scopeSlotCount
if (fn.localSlotCaptures.getOrNull(local) == true) { if (fn.localSlotCaptures.getOrNull(local) == true) {
return localSlotToObj(local) return readLocalSlotValue(local)
} }
return when (frame.getSlotTypeCode(local)) { return when (frame.getSlotTypeCode(local)) {
SlotType.INT.code -> ObjInt.of(frame.getInt(local)) SlotType.INT.code -> ObjInt.of(frame.getInt(local))
SlotType.REAL.code -> ObjReal.of(frame.getReal(local)) SlotType.REAL.code -> ObjReal.of(frame.getReal(local))
SlotType.BOOL.code -> if (frame.getBool(local)) ObjTrue else ObjFalse SlotType.BOOL.code -> if (frame.getBool(local)) ObjTrue else ObjFalse
SlotType.OBJ.code -> { SlotType.OBJ.code -> readLocalSlotValue(local)
val obj = frame.getObj(local) else -> readLocalSlotValue(local)
when (obj) {
is FrameSlotRef -> obj.read()
is RecordSlotRef -> obj.read()
else -> obj
} }
} }
else -> localSlotToObj(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
}
}
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)) { return when (frame.getSlotTypeCode(localIndex)) {
SlotType.INT.code -> ObjInt.of(frame.getInt(localIndex)) SlotType.INT.code -> ObjInt.of(frame.getInt(localIndex))
SlotType.REAL.code -> ObjReal.of(frame.getReal(localIndex)) SlotType.REAL.code -> ObjReal.of(frame.getReal(localIndex))
@@ -4775,7 +4839,9 @@ class CmdFrame(
val obj = frame.getObj(localIndex) val obj = frame.getObj(localIndex)
when (obj) { when (obj) {
is FrameSlotRef -> obj.read() is FrameSlotRef -> obj.read()
is RecordSlotRef -> obj.read() is RecordSlotRef -> obj.read(scope, localName)
is ObjProperty -> resolvePropertyLikeLocal(localName, obj)
ObjUnset -> resolveUnsetLocal(localName)
else -> obj else -> obj
} }
} }
@@ -4783,13 +4849,34 @@ class CmdFrame(
val obj = frame.getObj(localIndex) val obj = frame.getObj(localIndex)
when (obj) { when (obj) {
is FrameSlotRef -> obj.read() is FrameSlotRef -> obj.read()
is RecordSlotRef -> obj.read() is RecordSlotRef -> obj.read(scope, localName)
is ObjProperty -> resolvePropertyLikeLocal(localName, obj)
ObjUnset -> resolveUnsetLocal(localName)
else -> obj 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 { private suspend fun getScopeSlotValue(slot: Int): Obj {
val target = scopeTarget(slot) val target = scopeTarget(slot)
val name = fn.scopeSlotNames[slot] val name = fn.scopeSlotNames[slot]
@@ -4878,16 +4965,33 @@ class CmdFrame(
private suspend fun setScopeSlotValueAtAddr(addrSlot: Int, value: Obj) { private suspend fun setScopeSlotValueAtAddr(addrSlot: Int, value: Obj) {
val target = addrScopes[addrSlot] ?: error("Address slot $addrSlot is not resolved") val target = addrScopes[addrSlot] ?: error("Address slot $addrSlot is not resolved")
val index = addrIndices[addrSlot] val index = addrIndices[addrSlot]
val record = target.getSlotRecord(index)
val slotId = addrScopeSlots[addrSlot] val slotId = addrScopeSlots[addrSlot]
val name = fn.scopeSlotNames.getOrNull(slotId) 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) target.assign(record, name, value)
return return
} }
target.setSlotValue(index, value) 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 { internal fun ensureScopeSlot(target: Scope, slot: Int): Int {
val name = fn.scopeSlotNames[slot] val name = fn.scopeSlotNames[slot]
if (name != null) { if (name != null) {
@@ -31,7 +31,7 @@ internal suspend fun seedFrameLocalsFromScope(frame: CmdFrame, scope: Scope) {
val record = scope.getLocalRecordDirect(name) val record = scope.getLocalRecordDirect(name)
?: scope.chainLookupIgnoreClosure(name, followClosure = true) ?: scope.chainLookupIgnoreClosure(name, followClosure = true)
?: continue ?: 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) scope.resolve(record, name)
} else { } else {
record.value 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) // Math helpers (scalar versions)
fun math1(name: String) = mod.funDoc( fun math1(name: String) = mod.funDoc(
name = name, name = name,
doc = StdlibInlineDocIndex.topFunDoc(name) ?: "Compute $name(x).", doc = StdlibInlineDocIndex.topFunDoc(name) ?: "Compute $name(x). Accepts Int, Real, and Decimal. Decimal currently uses a temporary Real bridge and will get native decimal implementations later.",
params = listOf(ParamDoc("x", type("lyng.Number"))) params = listOf(ParamDoc("x", type("lyng.Number")))
) )
math1("sin"); math1("cos"); math1("tan"); math1("asin"); math1("acos"); math1("atan") 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 = "floor", doc = StdlibInlineDocIndex.topFunDoc("floor") ?: "Round down the number to the nearest integer. Decimal is handled directly and stays Decimal.", 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 = "ceil", doc = StdlibInlineDocIndex.topFunDoc("ceil") ?: "Round up the number to the nearest integer. Decimal is handled directly and stays Decimal.", 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 = "round", doc = StdlibInlineDocIndex.topFunDoc("round") ?: "Round the number to the nearest integer. Decimal is handled directly and stays Decimal.", params = listOf(ParamDoc("x", type("lyng.Number"))))
// Hyperbolic and inverse hyperbolic // Hyperbolic and inverse hyperbolic
math1("sinh"); math1("cosh"); math1("tanh"); math1("asinh"); math1("acosh"); math1("atanh") math1("sinh"); math1("cosh"); math1("tanh"); math1("asinh"); math1("acosh"); math1("atanh")
// Exponentials and logarithms // 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 = "exp", doc = StdlibInlineDocIndex.topFunDoc("exp") ?: "Euler's exponential e^x. Decimal 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).", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "ln", doc = StdlibInlineDocIndex.topFunDoc("ln") ?: "Natural logarithm (base e). Decimal 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.", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "log10", doc = StdlibInlineDocIndex.topFunDoc("log10") ?: "Logarithm base 10. Decimal 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.", params = listOf(ParamDoc("x", type("lyng.Number")))) mod.funDoc(name = "log2", doc = StdlibInlineDocIndex.topFunDoc("log2") ?: "Logarithm base 2. Decimal 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 // Power/roots and absolute value
mod.funDoc( mod.funDoc(
name = "pow", name = "pow",
doc = StdlibInlineDocIndex.topFunDoc("pow") ?: "Raise `x` to the power `y`.", doc = StdlibInlineDocIndex.topFunDoc("pow") ?: "Raise `x` to the power `y`. Decimal with integral `y` is handled directly; other Decimal cases currently use a temporary Real bridge.",
params = listOf(ParamDoc("x", type("lyng.Number")), ParamDoc("y", type("lyng.Number"))) params = listOf(ParamDoc("x", type("lyng.Number")), ParamDoc("y", type("lyng.Number")))
) )
mod.funDoc( mod.funDoc(
name = "sqrt", name = "sqrt",
doc = StdlibInlineDocIndex.topFunDoc("sqrt") ?: "Square root of `x`.", doc = StdlibInlineDocIndex.topFunDoc("sqrt") ?: "Square root of `x`. Decimal currently uses a temporary Real bridge and will get a native decimal implementation later.",
params = listOf(ParamDoc("x", type("lyng.Number"))) params = listOf(ParamDoc("x", type("lyng.Number")))
) )
mod.funDoc( mod.funDoc(
name = "abs", 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 Decimal stays Decimal.",
params = listOf(ParamDoc("x", type("lyng.Number"))) params = listOf(ParamDoc("x", type("lyng.Number")))
) )
@@ -591,11 +591,14 @@ open class Obj {
return obj.copy(value = res, type = ObjRecord.Type.Other) return obj.copy(value = res, type = ObjRecord.Type.Other)
} }
val value = obj.value val value = obj.value
if (value is ObjProperty || obj.type == ObjRecord.Type.Property) { if (value is ObjProperty) {
val prop = (value as? ObjProperty) val res = value.callGetter(scope, this, decl)
?: scope.raiseError("Expected ObjProperty for property member $name, got ${value::class}") return obj.copy(value = res, type = ObjRecord.Type.Other)
val res = prop.callGetter(scope, this, decl) }
return ObjRecord(res, obj.isMutable) 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 val caller = scope.currentClassCtx
// Check visibility for non-property members here if they weren't checked before // Check visibility for non-property members here if they weren't checked before
@@ -17,33 +17,25 @@
package net.sergeych.lyng.obj 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.DecimalMode
import com.ionspin.kotlin.bignum.decimal.RoundingMode import com.ionspin.kotlin.bignum.decimal.RoundingMode
import com.ionspin.kotlin.bignum.integer.BigInteger import com.ionspin.kotlin.bignum.integer.BigInteger
import net.sergeych.lyng.Arguments import net.sergeych.lyng.*
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.miniast.addPropertyDoc import net.sergeych.lyng.miniast.addPropertyDoc
import net.sergeych.lyng.miniast.type import net.sergeych.lyng.miniast.type
import net.sergeych.lyng.requiredArg import net.sergeych.lyng.requiredArg
import com.ionspin.kotlin.bignum.decimal.BigDecimal as IonBigDecimal
object ObjBigDecimalSupport { object ObjDecimalSupport {
private const val decimalContextVar = "__lyng_decimal_context__" private const val decimalContextVar = "__lyng_decimal_context__"
// For Real -> BigDecimal, preserve the actual IEEE-754 Double value using a // For Real -> Decimal, preserve the actual IEEE-754 Double value using a
// round-trip-safe precision. This intentionally does not try to recover source text. // round-trip-safe precision. This intentionally does not try to recover source text.
private val realConversionMode = DecimalMode(17L, RoundingMode.ROUND_HALF_TO_EVEN) private val realConversionMode = DecimalMode(17L, RoundingMode.ROUND_HALF_TO_EVEN)
// Division needs an explicit stopping rule for non-terminating results. Use a // Division needs an explicit stopping rule for non-terminating results. Use a
// decimal128-like default context until Lyng exposes per-operation contexts. // decimal128-like default context until Lyng exposes per-operation contexts.
private val defaultDivisionMode = DecimalMode(34L, RoundingMode.ROUND_HALF_TO_EVEN) private val defaultDivisionMode = DecimalMode(34L, RoundingMode.ROUND_HALF_TO_EVEN)
private val zero: IonBigDecimal = IonBigDecimal.ZERO private val zero: IonBigDecimal = IonBigDecimal.ZERO
private val decimalTypeDecl = TypeDecl.Simple("lyng.decimal.BigDecimal", false) private val decimalTypeDecl = TypeDecl.Simple("lyng.decimal.Decimal", false)
private object BoundMarker private object BoundMarker
private data class DecimalRuntimeContext( private data class DecimalRuntimeContext(
val precision: Long, val precision: Long,
@@ -51,7 +43,7 @@ object ObjBigDecimalSupport {
) : Obj() ) : Obj()
suspend fun bindTo(module: ModuleScope) { suspend fun bindTo(module: ModuleScope) {
val decimalClass = module.requireClass("BigDecimal") val decimalClass = module.requireClass("Decimal")
if (decimalClass.kotlinClassData === BoundMarker) return if (decimalClass.kotlinClassData === BoundMarker) return
decimalClass.kotlinClassData = BoundMarker decimalClass.kotlinClassData = BoundMarker
decimalClass.isAbstract = false decimalClass.isAbstract = false
@@ -88,6 +80,9 @@ object ObjBigDecimalSupport {
decimalClass.addFn("toReal") { decimalClass.addFn("toReal") {
ObjReal.of(valueOf(thisObj).doubleValue(false)) ObjReal.of(valueOf(thisObj).doubleValue(false))
} }
decimalClass.addFn("toString") {
ObjString(valueOf(thisObj).toStringExpanded())
}
decimalClass.addFn("toStringExpanded") { decimalClass.addFn("toStringExpanded") {
ObjString(valueOf(thisObj).toStringExpanded()) ObjString(valueOf(thisObj).toStringExpanded())
} }
@@ -104,7 +99,7 @@ object ObjBigDecimalSupport {
try { try {
newInstance(decimalClass, IonBigDecimal.parseStringWithMode(value)) newInstance(decimalClass, IonBigDecimal.parseStringWithMode(value))
} catch (e: Throwable) { } catch (e: Throwable) {
requireScope().raiseIllegalArgument("invalid BigDecimal string: $value") requireScope().raiseIllegalArgument("invalid Decimal string: $value")
} }
} }
module.addFn("withDecimalContext") { module.addFn("withDecimalContext") {
@@ -133,8 +128,45 @@ object ObjBigDecimalSupport {
registerInterop(decimalClass) registerInterop(decimalClass)
} }
fun isDecimalValue(value: Obj): Boolean =
value is ObjInstance && value.objClass.className == "Decimal"
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)
suspend fun newDecimal(scope: ScopeFacade, value: IonBigDecimal): ObjInstance {
val decimalModule = scope.requireScope().currentImportProvider.createModuleScope(scope.pos, "lyng.decimal")
val decimalClass = decimalModule.requireClass("Decimal")
return scope.newInstance(decimalClass, value)
}
private fun valueOf(obj: Obj): IonBigDecimal { private fun valueOf(obj: Obj): IonBigDecimal {
val instance = obj as? ObjInstance ?: error("BigDecimal receiver must be an object instance") val instance = obj as? ObjInstance ?: error("Decimal receiver must be an object instance")
return instance.kotlinInstanceData as? IonBigDecimal ?: zero return instance.kotlinInstanceData as? IonBigDecimal ?: zero
} }
@@ -160,21 +192,27 @@ object ObjBigDecimalSupport {
private suspend fun ScopeFacade.newInstance(decimalClass: ObjClass, value: IonBigDecimal): ObjInstance { private suspend fun ScopeFacade.newInstance(decimalClass: ObjClass, value: IonBigDecimal): ObjInstance {
val instance = call(decimalClass) as? ObjInstance val instance = call(decimalClass) as? ObjInstance
?: raiseIllegalState("BigDecimal() did not return an object instance") ?: raiseIllegalState("Decimal() did not return an object instance")
instance.kotlinInstanceData = value instance.kotlinInstanceData = value
return instance return instance
} }
private suspend fun ScopeFacade.newInstanceLikeDecimal(sample: Obj, value: IonBigDecimal): ObjInstance {
val decimalClass = (sample as? ObjInstance)?.objClass
?: raiseIllegalState("Decimal sample must be an object instance")
return newInstance(decimalClass, value)
}
private fun coerceArg(scope: Scope, value: Obj): IonBigDecimal = when (value) { private fun coerceArg(scope: Scope, value: Obj): IonBigDecimal = when (value) {
is ObjInt -> IonBigDecimal.fromLongAsSignificand(value.value) is ObjInt -> IonBigDecimal.fromLongAsSignificand(value.value)
is ObjReal -> IonBigDecimal.fromDouble(value.value, realConversionMode) is ObjReal -> IonBigDecimal.fromDouble(value.value, realConversionMode)
is ObjInstance -> { is ObjInstance -> {
if (value.objClass.className != "BigDecimal") { if (value.objClass.className != "Decimal") {
scope.raiseIllegalArgument("expected BigDecimal-compatible value, got ${value.objClass.className}") scope.raiseIllegalArgument("expected Decimal-compatible value, got ${value.objClass.className}")
} }
value.kotlinInstanceData as? IonBigDecimal ?: zero value.kotlinInstanceData as? IonBigDecimal ?: zero
} }
else -> scope.raiseIllegalArgument("expected BigDecimal-compatible value, got ${value.objClass.className}") else -> scope.raiseIllegalArgument("expected Decimal-compatible value, got ${value.objClass.className}")
} }
private suspend fun normalizeContext(scope: Scope, value: Obj): DecimalRuntimeContext { private suspend fun normalizeContext(scope: Scope, value: Obj): DecimalRuntimeContext {
@@ -253,34 +291,40 @@ 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) { private fun registerBuiltinConversions(decimalClass: ObjClass) {
ObjInt.type.addPropertyDoc( ObjInt.type.addPropertyDoc(
name = "d", name = "d",
doc = "Convert this integer to a BigDecimal.", doc = "Convert this integer to a Decimal.",
type = type("lyng.decimal.BigDecimal"), type = type("lyng.decimal.Decimal"),
moduleName = "lyng.decimal", moduleName = "lyng.decimal",
getter = { newInstance(decimalClass, IonBigDecimal.fromLongAsSignificand(thisAs<ObjInt>().value)) } getter = { newInstance(decimalClass, IonBigDecimal.fromLongAsSignificand(thisAs<ObjInt>().value)) }
) )
ObjInt.type.members["d"] = ObjInt.type.members.getValue("d").copy(typeDecl = decimalTypeDecl) ObjInt.type.members["d"] = ObjInt.type.members.getValue("d").copy(typeDecl = decimalTypeDecl)
ObjReal.type.addPropertyDoc( ObjReal.type.addPropertyDoc(
name = "d", name = "d",
doc = "Convert this real number to a BigDecimal by preserving the current IEEE-754 value with 17 significant digits and half-even rounding.", doc = "Convert this real number to a Decimal by preserving the current IEEE-754 value with 17 significant digits and half-even rounding.",
type = type("lyng.decimal.BigDecimal"), type = type("lyng.decimal.Decimal"),
moduleName = "lyng.decimal", moduleName = "lyng.decimal",
getter = { newInstance(decimalClass, IonBigDecimal.fromDouble(thisAs<ObjReal>().value, realConversionMode)) } getter = { newInstance(decimalClass, IonBigDecimal.fromDouble(thisAs<ObjReal>().value, realConversionMode)) }
) )
ObjReal.type.members["d"] = ObjReal.type.members.getValue("d").copy(typeDecl = decimalTypeDecl) ObjReal.type.members["d"] = ObjReal.type.members.getValue("d").copy(typeDecl = decimalTypeDecl)
ObjString.type.addPropertyDoc( ObjString.type.addPropertyDoc(
name = "d", name = "d",
doc = "Parse this string as a BigDecimal.", doc = "Parse this string as a Decimal.",
type = type("lyng.decimal.BigDecimal"), type = type("lyng.decimal.Decimal"),
moduleName = "lyng.decimal", moduleName = "lyng.decimal",
getter = { getter = {
val value = thisAs<ObjString>().value val value = thisAs<ObjString>().value
try { try {
newInstance(decimalClass, IonBigDecimal.parseStringWithMode(value)) newInstance(decimalClass, IonBigDecimal.parseStringWithMode(value))
} catch (e: Throwable) { } catch (e: Throwable) {
requireScope().raiseIllegalArgument("invalid BigDecimal string: $value") requireScope().raiseIllegalArgument("invalid Decimal string: $value")
} }
} }
) )
@@ -587,6 +587,10 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
} }
override suspend fun compareTo(scope: Scope, other: Obj): Int { override suspend fun compareTo(scope: Scope, other: Obj): Int {
val explicitCompare = objClass.getInstanceMemberOrNull("compareTo", includeStatic = false)
if (explicitCompare != null) {
return invokeInstanceMethod(scope, "compareTo", Arguments(other)).cast<ObjInt>(scope).toInt()
}
if (other !is ObjInstance || other.objClass != objClass) { if (other !is ObjInstance || other.objClass != objClass) {
OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { return it } OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { return it }
return -1 return -1
@@ -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())
}
@@ -48,7 +48,7 @@ enum DecimalRounding {
/** /**
* Dynamic decimal arithmetic settings. * Dynamic decimal arithmetic settings.
* *
* A decimal context is not attached permanently to a `BigDecimal` value. Instead, it is applied dynamically * A decimal context is not attached permanently to a `Decimal` value. Instead, it is applied dynamically
* inside `withDecimalContext(...)`, which makes the rule local to a block of code. * inside `withDecimalContext(...)`, which makes the rule local to a block of code.
* *
* Default context: * Default context:
@@ -76,7 +76,7 @@ class DecimalContext(
/** /**
* Arbitrary-precision decimal value. * Arbitrary-precision decimal value.
* *
* `BigDecimal` is intended for decimal arithmetic where binary floating-point (`Real`) is the wrong tool: * `Decimal` is intended for decimal arithmetic where binary floating-point (`Real`) is the wrong tool:
* - money * - money
* - human-entered decimal values * - human-entered decimal values
* - ratios that should round in decimal, not in binary * - ratios that should round in decimal, not in binary
@@ -84,10 +84,10 @@ class DecimalContext(
* *
* Creating values: * Creating values:
* *
* - `1.d` converts `Int -> BigDecimal` * - `1.d` converts `Int -> Decimal`
* - `2.2.d` converts `Real -> BigDecimal` by preserving the current IEEE-754 value * - `2.2.d` converts `Real -> Decimal` by preserving the current IEEE-754 value
* - `"2.2".d` parses exact decimal text * - `"2.2".d` parses exact decimal text
* - `BigDecimal.fromInt(...)`, `fromReal(...)`, `fromString(...)` are explicit factory forms * - `Decimal.fromInt(...)`, `fromReal(...)`, `fromString(...)` are explicit factory forms
* *
* Important distinction: * Important distinction:
* *
@@ -109,7 +109,7 @@ class DecimalContext(
* *
* Mixed arithmetic: * Mixed arithmetic:
* *
* `BigDecimal` defines its own operators against decimal-compatible values, and the decimal module also registers * `Decimal` defines its own operators against decimal-compatible values, and the decimal module also registers
* interop bridges so built-in left-hand operands work naturally: * interop bridges so built-in left-hand operands work naturally:
* *
* import lyng.decimal * import lyng.decimal
@@ -134,15 +134,15 @@ class DecimalContext(
* *
* "2.2".d * "2.2".d
* *
* That is the precise form. `2.2.d` remains a `Real -> BigDecimal` conversion by design. * That is the precise form. `2.2.d` remains a `Real -> Decimal` conversion by design.
*/ */
extern class BigDecimal() { extern class Decimal() {
/** Add another decimal-compatible value. */ /** Add another decimal-compatible value. */
extern fun plus(other: Object): BigDecimal extern fun plus(other: Object): Decimal
/** Subtract another decimal-compatible value. */ /** Subtract another decimal-compatible value. */
extern fun minus(other: Object): BigDecimal extern fun minus(other: Object): Decimal
/** Multiply by another decimal-compatible value. */ /** Multiply by another decimal-compatible value. */
extern fun mul(other: Object): BigDecimal extern fun mul(other: Object): Decimal
/** /**
* Divide by another decimal-compatible value. * Divide by another decimal-compatible value.
* *
@@ -150,13 +150,13 @@ extern class BigDecimal() {
* - by default: `34` significant digits, `HalfEven` * - by default: `34` significant digits, `HalfEven`
* - inside `withDecimalContext(...)`: the context active for the current block * - inside `withDecimalContext(...)`: the context active for the current block
*/ */
extern fun div(other: Object): BigDecimal extern fun div(other: Object): Decimal
/** Remainder with another decimal-compatible value. */ /** Remainder with another decimal-compatible value. */
extern fun mod(other: Object): BigDecimal extern fun mod(other: Object): Decimal
/** Compare with another decimal-compatible value. */ /** Compare with another decimal-compatible value. */
extern fun compareTo(other: Object): Int extern fun compareTo(other: Object): Int
/** Unary minus. */ /** Unary minus. */
extern fun negate(): BigDecimal extern fun negate(): Decimal
/** Convert to `Int` by dropping the fractional part according to backend conversion rules. */ /** Convert to `Int` by dropping the fractional part according to backend conversion rules. */
extern fun toInt(): Int extern fun toInt(): Int
/** Convert to `Real`. */ /** Convert to `Real`. */
@@ -169,16 +169,16 @@ extern class BigDecimal() {
extern fun toStringExpanded(): String extern fun toStringExpanded(): String
/** Create a decimal from an `Int`. */ /** Create a decimal from an `Int`. */
static extern fun fromInt(value: Int): BigDecimal static extern fun fromInt(value: Int): Decimal
/** /**
* Create a decimal from a `Real`. * Create a decimal from a `Real`.
* *
* This preserves the current IEEE-754 value using a round-trip-safe decimal conversion. * This preserves the current IEEE-754 value using a round-trip-safe decimal conversion.
* It does not try to recover the original source text. * It does not try to recover the original source text.
*/ */
static extern fun fromReal(value: Real): BigDecimal static extern fun fromReal(value: Real): Decimal
/** Parse exact decimal text. */ /** Parse exact decimal text. */
static extern fun fromString(value: String): BigDecimal static extern fun fromString(value: String): Decimal
} }
/** /**
@@ -97,7 +97,7 @@ enum BinaryOperator {
* The registry is symmetric for the converted values, but not for the original syntax. * The registry is symmetric for the converted values, but not for the original syntax.
* Its job is specifically to fill the gap where your custom type appears on the right: * Its job is specifically to fill the gap where your custom type appears on the right:
* *
* - `myDecimal + 1` usually already works if `BigDecimal.plus(Int)` exists * - `myDecimal + 1` usually already works if `Decimal.plus(Int)` exists
* - `1 + myDecimal` needs registration because `Int` itself is not rewritten * - `1 + myDecimal` needs registration because `Int` itself is not rewritten
* *
* Typical pattern for a custom type: * Typical pattern for a custom type:
@@ -135,7 +135,7 @@ enum BinaryOperator {
* - `3 > Rational(5, 2)` works * - `3 > Rational(5, 2)` works
* - `2 == Rational(2, 1)` works * - `2 == Rational(2, 1)` works
* *
* Decimal uses the same mechanism internally to make `Int + BigDecimal` and `Real + BigDecimal` * Decimal uses the same mechanism internally to make `Int + Decimal` and `Real + Decimal`
* work without changing the built-in `Int` or `Real` classes. * work without changing the built-in `Int` or `Real` classes.
*/ */
extern object OperatorInterop { extern object OperatorInterop {
@@ -18,8 +18,14 @@
package net.sergeych.lyng package net.sergeych.lyng
import kotlinx.coroutines.test.runTest 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.bindGlobalVar
import net.sergeych.lyng.bridge.globalBinder 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.Test
import kotlin.test.assertEquals import kotlin.test.assertEquals
@@ -49,4 +55,97 @@ class GlobalPropertyCaptureRegressionTest {
assertEquals(2.0, x, "bound extern var should stay live inside function bodies") 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")
} }
@@ -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()
)
}
}
@@ -17,10 +17,12 @@
package net.sergeych.lyng package net.sergeych.lyng
import com.ionspin.kotlin.bignum.decimal.BigDecimal
import kotlinx.coroutines.test.runTest import kotlinx.coroutines.test.runTest
import kotlin.test.Test import kotlin.test.Test
import kotlin.test.assertEquals
class BigDecimalModuleTest { class DecimalModuleTest {
@Test @Test
fun testDecimalModuleFactoriesAndConversions() = runTest { fun testDecimalModuleFactoriesAndConversions() = runTest {
val scope = Script.newScope() val scope = Script.newScope()
@@ -28,8 +30,8 @@ class BigDecimalModuleTest {
""" """
import lyng.decimal import lyng.decimal
assertEquals("12.34", BigDecimal.fromString("12.34").toStringExpanded()) assertEquals("12.34", Decimal.fromString("12.34").toStringExpanded())
assertEquals("1", BigDecimal.fromInt(1).toStringExpanded()) assertEquals("1", Decimal.fromInt(1).toStringExpanded())
assertEquals("2.5", "2.5".d.toStringExpanded()) assertEquals("2.5", "2.5".d.toStringExpanded())
assertEquals("1", 1.d.toStringExpanded()) assertEquals("1", 1.d.toStringExpanded())
assertEquals("2.2", 2.2.d.toStringExpanded()) assertEquals("2.2", 2.2.d.toStringExpanded())
@@ -135,4 +137,116 @@ class BigDecimalModuleTest {
""".trimIndent() """.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 Decimal
val floorPos = floor("2.9".d) as Decimal
val floorNeg = floor("-2.1".d) as Decimal
val ceilPos = ceil("2.1".d) as Decimal
val ceilNeg = ceil("-2.1".d) as Decimal
val roundPos = round("2.5".d) as Decimal
val roundNeg = round("-2.5".d) as Decimal
val powInt = pow("1.5".d, 2) as Decimal
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 Decimal
val expDecimal = exp("1.25".d) as Decimal
val sqrtDecimal = sqrt("2".d) as Decimal
val lnDecimal = ln("2".d) as Decimal
val log10Decimal = log10("2".d) as Decimal
val log2Decimal = log2("2".d) as Decimal
val powDecimal = pow("2".d, "0.5".d) as Decimal
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 Decimal)
assertEquals(Decimal, 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)
""")
}
@Test
fun kotlinHelperCanWrapIonBigDecimal() = runTest {
val scope = Script.newScope()
val decimal = scope.asFacade().newDecimal(BigDecimal.parseStringWithMode("12.34"))
assertEquals("Decimal", decimal.objClass.className)
assertEquals("12.34", decimal.toString(scope).value)
assertEquals("12.34", decimal.invokeInstanceMethod(scope, "toStringExpanded").cast<net.sergeych.lyng.obj.ObjString>(scope).value)
}
@Test
fun testDecimalComparisons() = runTest {
eval("""
import lyng.decimal
val X = 42.d
assert(X < 43.d)
assert(X < 43)
assert(X == 42)
""".trimIndent())
}
} }
@@ -0,0 +1,188 @@
/*
* 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())
}
@Test
fun testMatrixAndVectorComparisons() = runTest {
eval("""
import lyng.matrix
val v0 = vector([1, 2, 3])
val v1 = vector([1, 2, 4])
assert(v0 < v1)
assert(v0 == vector([1, 2, 3]))
val m0 = matrix([[1, 2], [3, 4]])
val m1 = matrix([[1, 2], [3, 5]])
assert(m0 < m1)
assert(m0 == matrix([[1, 2], [3, 4]]))
""".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())
}
}
@@ -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
}
}
@@ -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)
}
+134
View File
@@ -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 }
)
+157
View File
@@ -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)
+11 -4
View File
@@ -77,10 +77,17 @@ extern class MapEntry<K,V> : Array<Object> {
} }
// Built-in math helpers (implemented in host runtime). // Built-in math helpers (implemented in host runtime).
extern fun abs(x: Object): Real //
extern fun ln(x: Object): Real // Decimal note:
extern fun pow(x: Object, y: Object): Real // - these helpers accept `Decimal` values too
extern fun sqrt(x: Object): Real // - `abs`, `floor`, `ceil`, `round`, and `pow(x, y)` with integral `y` keep decimal arithmetic
// - the remaining decimal cases currently use a temporary bridge:
// `Decimal -> Real -> host math -> Decimal`
// - 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 extern fun clamp<T>(value: T, range: Range<T>): T
class SeededRandom { class SeededRandom {
+2 -2
View File
@@ -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"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -21,7 +21,7 @@
plugins { plugins {
alias(libs.plugins.kotlinMultiplatform) 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" id("org.jetbrains.compose") version "1.9.3"
`maven-publish` `maven-publish`
} }
+36
View File
@@ -0,0 +1,36 @@
# Decimal Math TODO
These stdlib math helpers currently accept `Decimal`, but some still use the temporary compatibility path
`Decimal -> Real -> host math -> Decimal`
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
View File
@@ -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"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -21,8 +21,8 @@
plugins { plugins {
alias(libs.plugins.kotlinMultiplatform) alias(libs.plugins.kotlinMultiplatform)
// Compose compiler plugin for Kotlin 2.2.21 (matches version catalog) // Compose compiler plugin aligned with the project Kotlin version.
id("org.jetbrains.kotlin.plugin.compose") version "2.2.21" id("org.jetbrains.kotlin.plugin.compose") version "2.3.20"
// Compose Multiplatform plugin for convenient dependencies (compose.html.core, etc.) // Compose Multiplatform plugin for convenient dependencies (compose.html.core, etc.)
id("org.jetbrains.compose") version "1.9.3" 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 // Ensure any ProcessResources task depends on docs index generation so the JSON is packaged
tasks.configureEach { tasks.configureEach {
if (name.endsWith("ProcessResources")) { if (name.endsWith("ProcessResources")) {
dependsOn(generateDocsIndex) dependsOn(generateDocsIndex, generateSiteVersion)
} }
} }
+2
View File
@@ -70,6 +70,7 @@ fun App() {
PageTemplate(title = when { PageTemplate(title = when {
isDocsRoute -> null isDocsRoute -> null
route.startsWith("authors") -> "Authors"
route.startsWith("reference") -> "Reference" route.startsWith("reference") -> "Reference"
route.isBlank() -> null route.isBlank() -> null
else -> null else -> null
@@ -118,6 +119,7 @@ fun App() {
Div({ classes("col-12", if (isDocsRoute) "col-lg-9" else "col-lg-12") }) { Div({ classes("col-12", if (isDocsRoute) "col-lg-9" else "col-lg-12") }) {
when { when {
route.isBlank() -> HomePage() route.isBlank() -> HomePage()
route.startsWith("authors") -> AuthorsPage()
route.startsWith("tryling") -> TryLyngPage(route) route.startsWith("tryling") -> TryLyngPage(route)
route.startsWith("search") -> SearchPage(route) route.startsWith("search") -> SearchPage(route)
!isDocsRoute -> ReferencePage() !isDocsRoute -> ReferencePage()
+63
View File
@@ -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) }
}
}
}
}
}
+9 -2
View File
@@ -287,8 +287,8 @@ fun HomePage() {
} }
} }
// Bottom section with a small Telegram button // Bottom section with Telegram and authors links
Div({ classes("text-center", "mt-5", "pb-4") }) { Div({ classes("text-center", "mt-5", "d-flex", "justify-content-center", "gap-2", "flex-wrap") }) {
A(attrs = { A(attrs = {
classes("btn", "btn-outline-primary", "btn-sm") classes("btn", "btn-outline-primary", "btn-sm")
attr("href", "https://t.me/lynglang") attr("href", "https://t.me/lynglang")
@@ -298,6 +298,13 @@ fun HomePage() {
I({ classes("bi", "bi-telegram", "me-1") }) I({ classes("bi", "bi-telegram", "me-1") })
Text("Join our Telegram channel") 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")
}
} }
} }
+10 -3
View File
@@ -332,16 +332,22 @@
<script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.11.1/highlight.min.js"></script> <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 --> <!-- 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="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.11.1/languages/go.min.js"></script>
<script src="lyng-version.js"></script>
</head> </head>
<body> <body>
<!-- Top-left version ribbon --> <!-- Top-left version ribbon -->
<div class="corner-ribbon bg-danger text-white"> <div class="corner-ribbon bg-danger text-white">
<span style="margin-left: -5em"> <span id="lyng-version-ribbon" style="margin-left: -5em">
v1.5.1
</span> </span>
</div> </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 --> <!-- 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 <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> to content</a>
@@ -384,6 +390,7 @@
<!-- Will be populated at runtime --> <!-- 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="#/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="#/reference" data-route="reference">Reference</a></li>
<li><a class="dropdown-item" href="#/authors" data-route="authors">Authors</a></li>
<li> <li>
<hr class="dropdown-divider"> <hr class="dropdown-divider">
</li> </li>
@@ -485,7 +492,7 @@
var activeLink = null; var activeLink = null;
if (!hash || hash === '#' || hash === '#/') { if (!hash || hash === '#' || hash === '#/') {
activeLink = document.querySelector('#topbarNav .nav-link[data-route="home"]'); 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 // Mark Docs menu root as active
activeLink = document.querySelector('#topbarNav .nav-link.dropdown-toggle'); activeLink = document.querySelector('#topbarNav .nav-link.dropdown-toggle');
} else if (hash.startsWith('#/reference')) { } else if (hash.startsWith('#/reference')) {
+18
View File
@@ -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)}")