Re domain specific module

.github/copilot-instructions.md

@@ -45,6 +45,17 @@ vecxt/
 │       ├── src-jvm/          # JVM-specific tests
 │       ├── src-js/           # Js-specific tests
 │       └── src-native/       # Scala Native-specific tests
+├── vecxt_re/                 # Domain specific library for reinsurance calculations
+│   ├── src/                  # Cross-platform shared source code
+│   ├── src-jvm/              # JVM-specific implementations (SIMD Vector API)
+│   ├── src-js/               # JavaScript-specific implementations
+│   ├── src-js-native/        # JavaScript / native shared (DRY) implementations
+│   ├── src-native/           # Scala Native-specific implementations
+│   └── test/                 # Cross-platform test suite (munit)
+│       ├── src/              # Shared test source files
+│       ├── src-jvm/          # JVM-specific tests
+│       ├── src-js/           # Js-specific tests
+│       └── src-native/       # Scala Native-specific tests
 ├── vecxt/                    # Main source directory and core published module
 │   ├── src/                  # Cross-platform shared source code
 │   ├── src-jvm/              # JVM-specific implementations (SIMD Vector API)
@@ -81,4 +92,8 @@ Follow styleguide.md for coding conventions
 Use inline methods where possible to avoid dispatch overhead where possible.
 
 ## GitHub Actions CI
-The project uses GitHub Actions for CI/CD
+The project uses GitHub Actions for CI/CD
+
+## Vecxt Re
+
+Contains a bunch of domain specific code for reinsurance calculations, structures, and various reinsurance contract types. It will often rely on Vecxt. You should view the principles as the same - correctness above all else - performance matters. It also aims to eexpose a consistent cross platform API.

.github/workflows/autofix.yml

@@ -0,0 +1,19 @@
+name: 'autofix.ci'
+on:
+  pull_request:
+jobs:
+  autofix:
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: 25
+
+      - name: Run autoformat
+        run: ./mill mill.scalalib.scalafmt.ScalafmtModule/reformatAll __.sources
+
+      - uses: autofix-ci/action@ff86a557419858bb967097bfc916833f5647fa8c

.github/workflows/ci.yml

@@ -68,6 +68,9 @@ jobs:
       - name: Test
         run: ./mill vecxtensions.${{ matrix.project }}.test
 
+      - name: Test
+        run: ./mill vecxt_re.${{ matrix.project }}.test
+
       - name: Laws Test
         if: matrix.project == 'jvm'
         run: ./mill laws.${{ matrix.project }}.test

.gitignore

@@ -38,3 +38,6 @@ weights2.csv
 biases1.csv
 biases2.csv
 .DS_Store
+
+.venv/
+experiments/src/bhd.scala

.vscode/launch.json

@@ -1,49 +1,35 @@
 {
-  // Use IntelliSense to learn about possible attributes.
-  // Hover to view descriptions of existing attributes.
-  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
   "version": "0.2.0",
   "configurations": [
     {
       "type": "scala",
       "request": "launch",
-      "name": "test Suite",
-      "buildTarget": "vecxt.jvm.test",
-      "testClass": "vecxt.LongArraysSuite",
-      "jvmOptions": [
-        "--add-modules=jdk.incubator.vector"
-      ],
-      "args": [
-        "-oD"
-      ]
+      "name": "plotIndex",
+      "mainClass": "experiments.plotIndex",
+      "buildTarget": "file:///Users/simon/Code/vecxt/experiments",
+      "args": [],
+      "jvmOptions": [],
+      "env": {}
     },
     {
       "type": "scala",
       "request": "launch",
-      "name": "debug test",
-      "buildTarget": "vecxt.jvm.test",
-      "testClass": "vecxt.MatrixAdditionTest",
-      "jvmOptions": [
-        "--add-modules=jdk.incubator.vector"
-      ],
-      "args": [
-        "-oD"
-      ],
-      "env": {},
-      "internalConsoleOptions": "openOnSessionStart",
-      "preLaunchTask": "",
-      "postDebugTask": ""
+      "name": "readXl",
+      "mainClass": "experiments.readXl",
+      "buildTarget": "file:///Users/simon/Code/vecxt/experiments",
+      "args": [],
+      "jvmOptions": [],
+      "env": {}
     },
     {
       "type": "scala",
-      "request": "attach",
-      "name": "Attach debugger",
-      // name of the module that is being debugging
-      "buildTarget": "vecxt.jvm.test",
-      // Host of the jvm to connect to
-      "hostName": "localhost",
-      // Port to connect to
-      "port": 5005
+      "request": "launch",
+      "name": "pricingFun",
+      "mainClass": "experiments.pricingFun",
+      "buildTarget": "file:///Users/simon/Code/vecxt/experiments",
+      "args": [],
+      "jvmOptions": [],
+      "env": {}
     }
   ]
 }

.vscode/mcp.json

@@ -1,8 +1,8 @@
 {
   "servers": {
     "vecxt-metals": {
-      "url": "http://localhost:51891/sse",
-      "type": "sse"
+      "url": "http://localhost:51891/mcp",
+      "type": "http"
     }
   }
 }

.vscode/tasks.json

@@ -4,7 +4,7 @@
     {
       "label": "compiledClassesAndSemanticDbFiles",
       "type": "shell",
-      "command": "./mill __.compiledClassesAndSemanticDbFiles",
+      "command": "./mill __.jvm.compiledClassesAndSemanticDbFiles",
       "runOptions": {
         "runOn": "folderOpen"
       },

benchmark/package.mill

@@ -9,7 +9,7 @@ object `package` extends JmhModule with ScalaModule:
   def scalaVersion = build.vecxt.jvm.scalaVersion
   def jmhCoreVersion = "1.37"
   override def forkArgs: T[Seq[String]] = super.forkArgs() ++ build.vecIncubatorFlag
-  override def moduleDeps: Seq[JavaModule] = Seq(build.vecxt.jvm, build.vecxtensions.jvm)
+  override def moduleDeps: Seq[JavaModule] = Seq(build.vecxt.jvm, build.vecxtensions.jvm, build.vecxt_re.jvm)
   def enableBsp = false
 
 // override def generateBenchmarkSources = T{

benchmark/src/LossReportBenchmark.scala

@@ -0,0 +1,94 @@
+package vecxt.benchmark
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import scala.compiletime.uninitialized
+import scala.util.Random
+import vecxt_re.*
+import vecxt_re.ReReporting.*
+import vecxt.all.*
+
+// ./mill benchmark.runJmh "vecxt.benchmark.LossReportBenchmark" -jvmArgs --add-modules=jdk.incubator.vector -rf json -wi 1 -i 3 -f 1
+
+/** 231] Benchmark (numEventsStr) (numIterationsStr) Mode Cnt Score Error Units 231] LossReportBenchmark.lossReport_fast
+  * 10000 100 thrpt 3 177346.981 ± 24137.324 ops/s 231] LossReportBenchmark.lossReport_fast 10000 1000 thrpt 3
+  * 180400.504 ± 8719.687 ops/s 231] LossReportBenchmark.lossReport_fast 100000 100 thrpt 3 11731.510 ± 1945.957 ops/s
+  * 231] LossReportBenchmark.lossReport_fast 100000 1000 thrpt 3 17443.246 ± 425.030 ops/s 231]
+  * LossReportBenchmark.lossReport_separate 10000 100 thrpt 3 46850.187 ± 7232.734 ops/s 231]
+  * LossReportBenchmark.lossReport_separate 10000 1000 thrpt 3 49876.719 ± 5238.487 ops/s 231]
+  * LossReportBenchmark.lossReport_separate 100000 100 thrpt 3 3360.234 ± 326.993 ops/s 231]
+  * LossReportBenchmark.lossReport_separate 100000 1000 thrpt 3 4706.819 ± 615.832 ops/s
+  */
+
+@State(Scope.Thread)
+class LossReportBenchmark extends BLASBenchmark:
+
+  @Param(Array("10000", "100000"))
+  var numEventsStr: String = uninitialized
+
+  @Param(Array("100", "1000"))
+  var numIterationsStr: String = uninitialized
+
+  var years: Array[Int] = uninitialized
+  var ceded: Array[Double] = uninitialized
+  var layerObj: Layer = uninitialized
+
+  @Setup(Level.Trial)
+  def setup: Unit =
+    val rng = new Random(0)
+    val numEvents = numEventsStr.toInt
+    val numIterations = numIterationsStr.toInt
+
+    val yrs = Array.ofDim[Int](numEvents)
+    var i = 0
+    while i < numEvents do
+      yrs(i) = rng.nextInt(numIterations) + 1 // 1-based group indices
+      i += 1
+    end while
+
+    java.util.Arrays.sort(yrs)
+
+    years = yrs
+
+    ceded = Array.ofDim[Double](numEvents)
+    i = 0
+    while i < numEvents do
+      // random loss values between 0 and 100
+      ceded(i) = rng.nextDouble() * 100.0
+      i += 1
+    end while
+
+    // Choose a layer with a moderate aggLimit to cause some exhaustion hits
+    layerObj = Layer(occLimit = Some(100.0), aggLimit = Some(50.0))
+    ()
+  end setup
+
+  @Benchmark
+  def lossReport_fast(bh: Blackhole) =
+    val calcd = (layerObj, ceded)
+    val r = calcd.lossReport(numIterationsStr.toInt, years, ReportDenominator.FirstLimit)
+    // consume fields so JMH doesn't optimize away
+    bh.consume(r.el)
+    bh.consume(r.stdDev)
+    bh.consume(r.attachProb)
+    bh.consume(r.exhaustProb)
+  end lossReport_fast
+
+  @Benchmark
+  def lossReport_separate(bh: Blackhole) =
+    val calcd = (layerObj, ceded)
+    val n = numIterationsStr.toInt
+    val reportLimit = ReportDenominator.FirstLimit.fromlayer(layerObj)
+
+    val el = calcd.expectedLoss(n) / reportLimit
+    val std = calcd.std(n, years) / reportLimit
+    val attach = calcd.attachmentProbability(n, years)
+    val exhaust = calcd.exhaustionProbability(n, years)
+
+    bh.consume(el)
+    bh.consume(std)
+    bh.consume(attach)
+    bh.consume(exhaust)
+  end lossReport_separate
+
+end LossReportBenchmark

benchmark/src/groupOpsBenchmark.scala

@@ -9,9 +9,12 @@ import org.openjdk.jmh.annotations.*
 import org.openjdk.jmh.infra.Blackhole
 import scala.compiletime.uninitialized
 import vecxtensions.*
+import vecxt_re.*
 import java.util.Random
 import java.util.concurrent.TimeUnit
 
+// ./mill benchmark.runJmh "vecxt.benchmark.LossReportBenchmark" -jvmArgs --add-modules=jdk.incubator.vector -rf json -wi 1 -i 3 -f 1
+
 @State(Scope.Thread)
 @BenchmarkMode(Array(Mode.AverageTime))
 @OutputTimeUnit(TimeUnit.NANOSECONDS)
@@ -91,11 +94,21 @@ class GroupOpsBenchmark:
     bh.consume(valuesCopy2)
   end benchGroupDiffInPlace
 
-  @Benchmark
-  def benchGroupSum(bh: Blackhole): Unit =
-    val (uniqueGroups, sums) = groupSum(groups, values)
-    bh.consume(uniqueGroups)
-    bh.consume(sums)
-  end benchGroupSum
+  // @Benchmark
+  // def benchGroupSum(bh: Blackhole): Unit =
+  //   // groupSum in vecxt_re takes nitr; compute number of groups then call it
+  //   var maxGroup = 0
+  //   var i = 0
+  //   while i < groups.length do
+  //     if groups(i) > maxGroup then maxGroup = groups(i)
+  //     end if
+  //     i += 1
+  //   end while
+  //   val numGroups = maxGroup + 1
+  //   val sums = groupSum(groups, values, numGroups)
+  //   val uniqueGroups = Array.tabulate(numGroups)(identity)
+  //   bh.consume(uniqueGroups)
+  //   bh.consume(sums)
+  // end benchGroupSum
 
 end GroupOpsBenchmark

benchmark/src/splitAmnt.scala

@@ -9,12 +9,12 @@ import org.openjdk.jmh.infra.Blackhole
 import scala.compiletime.uninitialized
 import vecxt.all.*
 import vecxt.all.given
-import vecxt.reinsurance.*
+import vecxt_re.*
 import jdk.incubator.vector.VectorSpecies
 import jdk.incubator.vector.VectorOperators
 import jdk.incubator.vector.DoubleVector
 import java.util.Random
-import vecxt.reinsurance.SplitLosses.splitAmntFast
+import vecxt_re.SplitLosses.splitAmntFast
 
 // mill benchmark.runJmh vecxt.benchmark.SplitAmntBenchmark -jvmArgs --add-modules=jdk.incubator.vector -rf json
 @State(Scope.Thread)

benchmark/src/variance.scala

@@ -10,10 +10,18 @@ import jdk.incubator.vector.VectorSpecies
 import jdk.incubator.vector.VectorOperators
 import jdk.incubator.vector.DoubleVector
 
+// ./mill benchmark.runJmh "vecxt.benchmark.VarianceBenchmark" -jvmArgs --add-modules=jdk.incubator.vector -rf json -wi 2 -i 3 -f 1
+
+/** 231] Benchmark (len) Mode Cnt Score Error Units 231] VarianceBenchmark.var_simd_twopass 1000 thrpt 3 1087302.435 ±
+  * 16013.286 ops/s 231] VarianceBenchmark.var_simd_twopass 100000 thrpt 3 9578.869 ± 334.606 ops/s 231]
+  * VarianceBenchmark.var_simd_welford 1000 thrpt 3 436244.559 ± 6158.585 ops/s 231] VarianceBenchmark.var_simd_welford
+  * 100000 thrpt 3 4187.715 ± 203.266 ops/s
+  */
+
 @State(Scope.Thread)
 class VarianceBenchmark extends BLASBenchmark:
 
-  @Param(Array("3", "128", "100000"))
+  @Param(Array("1000", "100000"))
   var len: String = uninitialized;
 
   var arr: Array[Double] = uninitialized
@@ -32,20 +40,29 @@ class VarianceBenchmark extends BLASBenchmark:
       vec.map(i => (i - μ) * (i - μ)).sumSIMD / (vec.length - 1)
   end extension
 
-
+  // @Benchmark
+  // def var_naive_twopass(bh: Blackhole) =
+  //   val r = arr.variance2
+  //   bh.consume(r);
+  // end var_naive_twopass
 
   @Benchmark
-  def var_loop(bh: Blackhole) =
-    val r = arr.variance2
+  def var_simd_twopass(bh: Blackhole) =
+    val r = arr.meanAndVarianceTwoPass(VarianceMode.Sample).variance
     bh.consume(r);
-  end var_loop
+  end var_simd_twopass
 
+  // @Benchmark
+  // def var_simd_welford(bh: Blackhole) =
+  //   val r = arr.meanAndVarianceWelfordSIMD(VarianceMode.Sample).variance
+  //   bh.consume(r);
+  // end var_simd_welford
 
-  @Benchmark
-  def var_vec(bh: Blackhole) =
-    val r = arr.variance
-    bh.consume(r);
-  end var_vec
+  // @Benchmark
+  // def var_default(bh: Blackhole) =
+  //   val r = arr.variance(VarianceMode.Sample)
+  //   bh.consume(r);
+  // end var_default
 end VarianceBenchmark