ActuarialIntelligence/Base

This system is a .NET-based actuarial intelligence framework that provides domain models, calculators, and infrastructure for financial risk analysis, including bond valuation, hazard rates, and Z-spreads. It extends beyond core actuarial math to support computer vision, text-to-speech animation, and PDF processing, while exposing these capabilities via ASP.NET Core APIs and Kubernetes-deployable services.

26 changes.

This period established the ActuarialIntelligence Framework by creating the initial repository structure, solution architecture, and foundational .NET libraries. It focused on building the core domain layer with mathematical, financial, and neural processing models, while simultaneously implementing infrastructure interfaces for data connectivity and serialization.

11 changes.

This period focused on establishing the core infrastructure by introducing the KubernetesService and WebAPI projects with Swagger documentation and Docker support. It also expanded the domain layer with new capabilities for actuarial calculations, PDF-to-image conversion, and Python script execution, alongside corresponding test harnesses and helper utilities.

6 changes.

This period focused on establishing the foundational infrastructure and initial implementations for several new projects, including the Kubernetes Log Analytics Connector and the ConnectedInstruction domain logic. It also involved creating early-stage applications for text-to-speech visualization and avatar animation, alongside adding reference code for TensorFlow object detection.

A new static helper class, APIConsumerHelper, has been added to the Calculators project to manage HTTP interactions. This component enables the serialization of objects to JSON and their transmission via HTTP requests (supporting methods like POST), followed by the deserialization of the response back into strongly-typed objects. This provides a centralized mechanism for the calculators to consume external REST APIs.

src/ActuarialIntelligence.Calculators/Helpers · high confidence

The domain layer now includes the ConnectedInstruction class and supporting files (including KXQueryConnection stubs) to handle dynamic expression parsing and execution against in-memory data grids, alongside the new VariableFunctionContainer to manage functionally variable coefficients.

src/ActuarialIntelligence.Domain/ConnectedInstruction · high confidence

Introduced two new .NET Framework 4.6 console applications, PDFTest and TestEXE, to serve as test harnesses. The PDFTest application demonstrates the usage of the ActuarialIntelligence.DependencyResolution library by invoking the pDFReformatter to process a specific PDF file, while TestEXE provides a basic empty entry point for general testing purposes.

src/PDFTest, src/TestEXE · high confidence

A new executable, PythonRunnerEXE, has been added to allow running general Python scripts from the command line. The tool accepts arguments for a script path and one or more image file locations (separated by pipes). It executes the specified Python script for each image, capturing and displaying standard output and error streams. Additionally, the executable includes built-in logic to detect specific green pixels in images and filter them, although this internal processing is not exposed as a separate user-facing feature in this diff.

src/PythonRunnerEXE · high confidence

The domain layer now includes new classes to support actuarial calculations and data storage patterns. Specifically, it introduces \KaplanMeier\ and \Hazard\ classes to compute survival functions, hazard rates, and probability density functions based on paired observations, as well as \ChapmanKolmogorov\ for jump probability calculations. Additionally, \ObjectStorePatternObject\ and related classes provide a structured way to manage row-based data storage using identifiers.

src/ActuarialIntelligence.Domain · high confidence

The domain layer now includes new static classes for statistical computations: BasicRegresssionCalcs provides methods to calculate the mean and variance for both double and decimal observation lists, while UnivariateRegressionFitting offers functions to fit exponential distributions and calculate normal distribution probability density values based on provided data points.

src/ActuarialIntelligence.Domain/Regression · high confidence

A new Program.cs file was added to the src/AI.TensorFlow directory containing a fully commented-out example for loading an SSD MobileNet V2 model from TensorFlow Hub, preprocessing an input image, running inference, and highlighting detected objects (specifically persons, knives, and guns) in the output. This serves as a reference implementation or template for using the TensorFlow.NET library for object detection tasks.

src/AI.TensorFlow · high confidence

A new console application entry point (Program.cs) was added to the APIConsumerTestApplication project. This application is designed to run a specific Python script (Recommendation.py) using a hardcoded local Python interpreter path. It executes the script, captures both standard output and standard error, and displays the results in the console, effectively serving as a test harness for invoking Python-based logic from a .NET environment.

src/APIConsumerTestApplication · high confidence

The infrastructure data layer now includes new Data Transfer Objects (DTOs) to structure query results and cash flow data, specifically \CashFlowSetDto\ for individual cash flow records and \QueryResultObject\ for aggregated query responses. Additionally, a \CustomerTimePeriods\ enum has been introduced to standardize time granularity (Yearly, Monthly, Daily), and standard assembly metadata has been added to support build and deployment processes.

src/ActuarialIntelligence.Infrastructure.Data · high confidence

Introduced a new set of domain model classes in the ContainerObjects namespace to support actuarial data structures. This includes BondDetails for bond parameters, Nominal and NominalCashflowSet for cash flow handling, ListTermCashflowSet and PlainListTermCashFlowSet for managing term-based cash flow collections, and SpotYield and TermCashflowYieldSet for yield data. Additionally, mathematical utility classes such as \_3Vector, \_3Matrix, Point, Points, and VectorPoints were added to support vector and matrix operations required for these calculations.

src/ActuarialIntelligence.Domain/ContainerObjects · high confidence

New domain enums have been introduced to the ActuarialIntelligence.Domain project to support specific business concepts and integration patterns. These include DateIncrementTypes (Year, Month, Day) and TimeIncrementTypes (MilliSecond, Second, Minute, Hour) for handling temporal granularity, RESTMethodType (GET, POST) for defining API interaction methods, Term (MonthlyEffective, YearlyEffective) for interest rate calculations, and FromTo for directional data flows. These types provide a structured, type-safe way to represent these values within the domain layer.

src/ActuarialIntelligence.Domain/Enums · high confidence

Introduced new financial instrument objects in the domain layer to support actuarial valuation: Annuity and AnnuityEquations for present value and Z-spread modeling, BondHalfYearly for bi-annual bond valuation, HalfYearlyBondYield for yield interpolation, and ZSpread for calculating Z-spreads via interpolation against nominal values.

src/ActuarialIntelligence.Domain/Financial Instrument Objects · high confidence

A new \nThDifferential\ class has been introduced in the domain layer to compute rows for solving differential equations involving a single variable. This class provides a \DifferentialRow\ method that generates a list of decimal values based on the order \n\, a constant, and step size \h\, utilizing a right-to-left enumeration convention for variable lists to support matrix-based solutions like Row Echelon reduction or QR decomposition.

src/ActuarialIntelligence.Domain/Differential · high confidence

Introduced the NeuralLearner static class to handle data aggregation and property extraction from domain objects, including methods to sum object heights and store aggregated results or specific property values into memory structures. Added the NeuralImagination class to perform extrapolation of object permeabilities using exponential distribution fitting. Implemented the NeuralMemmory generic class to serve as a storage container for these neural memory values, enabling the learner and processor objects to persist and retrieve processed data.

src/ActuarialIntelligence.Domain/NeuralLearners · high confidence

New reader implementations have been added to the infrastructure layer to support specific data retrieval needs. The ModelStatesSuggestionReader queries an Analysis Services data source to generate state transition probability suggestions based on configurable cluster and state range parameters. Additionally, the TermCashFlowSetReader retrieves term cash flow data and maps it into structured yield set objects for downstream processing.

src/ActuarialIntelligence.Infrastructure.Readers · high confidence

The WebAPI project has been initialized with a standard ASP.NET Core structure, including Program.cs, Startup.cs, and a ValuesController. The API now exposes Swagger/OpenAPI documentation via Swashbuckle, allowing users to view and interact with the API endpoints (such as the ZSpread calculation endpoint in ValuesController) through the Swagger UI interface.

src/WebAPI · high confidence

The ActuarialIntelligence.DependencyResolution module has been introduced to centralize the wiring of core infrastructure components. This includes registering the PDF reformatter, which utilizes Cyotek GhostScript to convert documents to high-resolution JPEG images, and the DMX/MDX data reader for state suggestions. Additionally, the module's configuration enforces a binding redirect for Newtonsoft.Json version 12.0.0.0 and targets the .NET Framework 4.8 runtime.

src/ActuarialIntelligence.DependencyResolution · high confidence

Introduced the foundational domain classes and interfaces for the NeuronParametrix module, including the IObject interface and NeuralObject class which define physical properties (Height, Width, Weight, Elasticity) and edge restriction logic. Added NeuralObjectList to manage collections of these objects and the static Objective class to define parameter requirements and error margins.

src/ActuarialIntelligence.Domain/NeuronParametrix · high confidence

This change establishes the initial repository structure, including a comprehensive README that introduces the ActuarialIntelligence Framework, its layered architecture (Data, Programmable, Analytics), and Domain-Driven Design principles with C\# code examples. It also adds a .gitattributes file to configure Git LFS for PNG images, a .gitignore for Visual Studio and .NET artifacts, and initial asset files like Ai.png and a Graphing.gif.

(repo-wide) · high confidence

This change introduces the foundational structure for the Actuarial Intelligence solution, including the main solution file and a diverse set of new projects. It adds a .NET console application for Text-to-Speech visualization (AI.TTS.EXE) that generates video from text files, a threading management library (AI.ThreadManagement) for parallel loop execution, and a Kubernetes Helm chart for service deployment. Additionally, it includes helper classes for dynamic object building and DTO-to-domain mapping, along with configuration files like .dockerignore and AssemblyInfo for various components.

src · high confidence

This change introduces the foundational domain layer for the ActuarialIntelligence project, adding core mathematical and matrix manipulation classes. The new code includes vector and matrix types (\_nVector, \_nMatrix, \_mnMatrix) with operations for arithmetic, transposition, and sub-matrix extraction. It also provides specific numerical linear algebra implementations, including Householder QR decomposition, Givens rotation matrices, and 3D rotation matrices, alongside utility classes for interpolation and numeric integration.

(repo-wide) · high confidence

This change introduces the BasicTTS application, a Windows Forms tool that synchronizes text input with animated facial expressions and body movements. The application features a main form with a VLC media player panel for video streaming, alongside PictureBox controls for eyes and mouth that update based on text content. It includes helper classes to map vowels to specific mouth images and random eye movements (including angry and worried states), and integrates ML.NET for predictive movement logic. The UI also supports dynamic background images for the character's body based on specific keywords in the input text.

src/BasicTTS · high confidence

This entry introduces the KubernetesService, a new .NET Core 2.1 ASP.NET web API. The service is configured with Swagger UI for API documentation and discovery, and includes Dockerfiles for both production and development environments to facilitate containerized deployment on Kubernetes.

src/KubernetesService · high confidence

Added the ConnectedInstructionEXE project, including its configuration file targeting .NET Framework 4.8, the main Program entry point, and assembly metadata. This establishes the executable structure for the Connected Instruction component.

src/ConnectedInstructionEXE · high confidence

This change introduces the initial project structure for the Kubernetes Log Analytics Connector, including an ASP.NET Core Web API controller for querying Azure Log Analytics, along with the necessary Dockerfiles, Kubernetes Helm chart templates, and configuration files to deploy the service. It also adds a new XML serialization implementation and a basic console application shell for Log Analytics connectivity, establishing the foundational code and deployment artifacts for this new component.

(repo-wide) · high confidence

Added a new static class \NeuralProcessor\ in the \ActuarialIntelligence.Domain.NeuralProcessor\ namespace. The class currently contains only a \Process\ method that splits an \Objective\ string and a detailed XML comment outlining design principles for physical realism, least-squares optimization, and dynamic property assignment. No functional logic is implemented yet.

src/ActuarialIntelligence.Domain/NeuralProcessors · high confidence

A new AtRisk class has been added to the PnL domain to represent risk metrics, storing the ProbabilityValue, NoAtRisk amount, and associated CustomerTimePeriods. This model provides the data structure required for the newly implemented Kolmogorov Chapman calculators.

src/ActuarialIntelligence.Domain/PnL · high confidence

The Kubernetes Service now exposes several new API controllers. The Domain controller provides endpoints for calculating Z-Spread and Annuity Present Values, as well as a general Z-Spread calculation and a test endpoint. A new ReadWriteToInMemoryObject controller allows clients to store and retrieve string and byte objects in memory. Additionally, a LogAnalyticsConnector controller enables querying Azure Log Analytics via a POST endpoint, and a test endpoint is available to execute Python scripts.

src/KubernetesService/Controllers · high confidence

ActuarialIntelligence now supports reformatting PDF documents into image arrays, allowing users to extract specific page ranges (start to end) as Bitmaps. This is enabled by new interfaces (ICalculate, IFormat) and a PDFReformatter class that delegates to a PDF formatter and extractor service.

src/ActuarialIntelligence.Calculators/Interfaces · high confidence

A new Windows Forms application (AI.TTS.Visual) has been added to visualize text-to-speech output by animating mouth shapes. The application reads text from a local file, splits it into characters, and displays corresponding mouth images (A, E, I, O, U, and L for spaces) in a main window with timing delays to simulate speech rhythm. It also includes an ImageDisplay helper class capable of recording these animations to an AVI video file using Emgu.CV, although the current main form implementation focuses on on-screen display rather than video output.

src/AI.TTS.Visual · high confidence

A new Windows Forms test application has been added to demonstrate the ActuarialIntelligence.Graphics library. This tool provides an interactive interface for rendering 3D vector data, featuring a main display for rotating and drawing point connections, an angle axis visualization, and controls to start and stop animations. It serves as a functional proof-of-concept for the underlying graphics rendering and mathematical transformation capabilities.

src/TestApplication · high confidence

The ActuarialIntelligence.Calculators library now includes several new calculation components: AtRiskCalculator for risk assessment, ChapmanKolmogorovCalculator for state-transition analysis, HazardPDFCalculator for generating hazard, PDF, and CDF triplets, and ZSpreadCalculator which delegates spread calculations to an external API via APIConsumerHelper. Additionally, ImageToModelCalculator provides utilities to extract pixel coordinates from images and convert them into 3D vector lists, supporting model generation from visual data.

src/ActuarialIntelligence.Calculators · high confidence

The ActuarialIntelligence.Infrastructure.Interfaces library now exposes a set of new contracts to define how the application interacts with data sources and storage. This includes generic interfaces for loading data (IDataConnection, IQueryDataConnection), low-level row-based retrieval (ILowLevelConnection), and a comprehensive hierarchy of data readers (IDataReader) supporting various parametric queries such as ID, time, hazard, and state transitions. Additionally, new interfaces for writing data (IDataWriter) and serializing/deserializing objects (ISerialize) have been added to standardize data persistence and format conversion across the system.

src/ActuarialIntelligence.Infrastructure.Interfaces · high confidence

The infrastructure layer now includes specific connection classes to load data from CSV files, HIVE databases, and SSRS (SQL Server Reporting Services) using MDX/DMX queries. CsvDataConnection leverages the FileHelpers engine to parse CSV files into generic object lists, HIVEConnection uses ODBC to execute SQL queries against a Hive data source, and SSRSConnection utilizes the AdomdClient to connect to an Analysis Services server and retrieve query results. These components implement the project's standard data connection interfaces to support diverse data ingestion needs.

src/ActuarialIntelligence.Infrastructure.Connections · high confidence

Added \DateIncrement\ and \TimeIncrement\ classes to the domain layer to handle arithmetic operations on date and time identifiers. These classes provide static methods to calculate new date and time IDs based on specified increments (years, months, days, hours, minutes, seconds, milliseconds) and to convert time increments into total hours, supporting the actuarial intelligence calculations.

src/ActuarialIntelligence.Domain/Date, src/ActuarialIntelligence.Domain/Time · high confidence

The domain layer now includes a set of new classes and interfaces to manage 3D vector point lists. BasicModelContainer provides a simple wrapper for an existing list of points, while SimpleFunctionContainer generates these points by evaluating a mathematical function over a configurable grid. Additionally, ImageToModelContainer introduces logic to process bitmap images into vector data, and the IModel/IModelContainer interfaces define the contract for these containers within the domain model.

src/ActuarialIntelligence.Domain/Model Containers · high confidence

A new \HazardPdfCdfHazardTriplet\ class has been added to the domain layer to structure calculator return data. This object encapsulates probability density functions (PDF), cumulative distribution functions (CDF), and hazard rates as lists of decimal points, along with metadata such as start date, state code, and population group ID, providing a structured container for actuarial calculation results.

src/ActuarialIntelligence.Domain/Calculator Return Objects · high confidence

A new \PDFFormatterAndExtractor\ class has been introduced in the \ActuarialIntelligence.Domain.PDF\ namespace to handle converting PDF documents into image formats. This component leverages the Cyotek GhostScript library to process PDF pages, supporting features such as password-protected files, configurable DPI/resolution, anti-aliasing, and various trim modes (PaperSize, TrimBox, CropBox). Users can now extract single pages or ranges of pages as Bitmap images directly from the domain layer.

src/ActuarialIntelligence.Domain/PDF · high confidence

Added test harness for Azure Computer Vision OCR and random data generation; Added tests for thread-based looping logic; Added unit tests for domain financial and mathematical operations.

This change introduces the foundational project structure for the Actuarial Intelligence solution, establishing multiple new libraries and applications including AI.TTS.EXE, AI.TTS.Visual, AI.TensorFlow, and various ActuarialIntelligence modules (Domain, Calculators, Infrastructure, etc.). It configures target frameworks (primarily .NET Framework 4.8, with some .NET 6.0 and .NET Core 3.1 projects) and adds initial NuGet package references such as Emgu.CV, OpenCvSharp4, SciSharp.TensorFlow.Redist, TensorFlow.NET, Ronz.Core, Ronz.Pdf, Newtonsoft.Json, and Microsoft.AnalysisServices packages to support computer vision, machine learning, PDF processing, and data connectivity features.

(dependencies) · high confidence

The Python scripts infrastructure now includes mypy cache data files (specifically for Python 3.7), which support faster subsequent type-checking runs by storing previously resolved symbol information.

src/ActuarialIntelligence.Infrastructure.PythonScripts · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 43 → 41 (-1.1)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 58 → 51 (-6.5)
• Architecture 84 → 84 (+0.0)
• Maturity 41 → 41 (+0.0)
• Readiness 32 → 29 (-2.9)
• Security 61 → 59 (-2.4)
• Domain Modelling 99 (new)

• Bounded contexts not declared
• Build action pinned to a mutable branch
• CommentedOutCode (src/AI.TensorFlow/Program.cs)
• CommentedOutCode (src/AI.TensorFlow/Program.cs)
• CommentedOutCode (src/AI.TensorFlow/Program.cs)
• CommentedOutCode (src/AI.TensorFlow/Program.cs)
• CommentedOutCode (src/ActuarialIntelligence.Domain/ConnectedInstruction/ConnectedInstruction.cs)
• CommentedOutCode (src/ActuarialIntelligence.Domain/ConnectedInstruction/ConnectedInstruction.cs)
• CommentedOutCode (src/ActuarialIntelligence.Domain/ConnectedInstruction/ConnectedInstruction.cs)
• CommentedOutCode (src/ActuarialIntelligence.Domain/ConnectedInstruction/ConnectedInstruction.cs)
• CommentedOutCode (src/ActuarialIntelligence.Domain/ConnectedInstruction/ConnectedInstruction.cs)
• CommentedOutCode (src/ActuarialIntelligence.Domain/ConnectedInstruction/ConnectedInstruction.cs)
• CommentedOutCode (src/ActuarialIntelligence.Domain/ConnectedInstruction/ConnectedInstruction.cs)
• CommentedOutCode (src/ActuarialIntelligence.Domain/ConnectedInstruction/ConnectedInstruction.cs)
• CommentedOutCode (src/ActuarialIntelligence.Domain/ConnectedInstruction/ConnectedInstruction.cs)
• CommentedOutCode (src/ActuarialIntelligence.Domain/ConnectedInstruction/ConnectedInstruction.cs)
• CommentedOutCode (src/ActuarialIntelligence.Domain/ConnectedInstruction/ConnectedInstruction.cs)
• CommentedOutCode (src/ActuarialIntelligence.Domain/ConnectedInstruction/KXQueryConnection.cs)
• CommentedOutCode (src/ActuarialIntelligence.Domain/ConnectedInstruction/KXQueryConnection.cs)
• CommentedOutCode (src/ActuarialIntelligence.Domain/ConnectedInstruction/KXQueryConnection.cs)
• …and 80 more

• CommentedOutCode (src/BasicTTS/MLHelper.cs)
• Documentation: no installation or build instructions (README.md)
• Duplicated block (11 lines × 2) (src/ActuarialIntelligence.Domain/Matrix/_mnMatrix.cs)
• Duplicated block (13 lines × 2) (src/AI.TTS.EXE/Program.cs)
• Duplicated block (13 lines × 2) (src/APIConsumerTestApplication/Program.cs)
• Duplicated block (14 lines × 2) (src/ActuarialIntelligence.Domain/Mathematical Technique Objects/HouseholderQR.cs)
• Duplicated block (14–16 lines × 3) (src/APIConsumerTestApplication/Program.cs)
• Duplicated block (16 lines × 2) (src/AI.TTS.EXE/Program.cs)
• Duplicated block (16 lines × 2) (src/ActuarialIntelligence.Domain/Mathematical Technique Objects/HouseholderQR.cs)
• Duplicated block (18 lines × 2) (src/BasicTTS/FormMainHelpers.cs)
• Duplicated block (21 lines × 2) (src/ActuarialIntelligence.Graphics/DrawGraphics.cs)
• Duplicated block (33 lines × 2) (src/ActuarialIntelligence.Calculators/ImageToModelCalculator.cs)
• Duplicated block (5 lines × 2) (src/KubernetesService/Controllers/ValuesController.cs)
• Duplicated block (5 lines × 3) (src/ActuarialIntelligence.Domain/Date/DateIncrement.cs)
• Duplicated block (7 lines × 2) (src/ActuarialIntelligence.Domain/Date/DateIncrement.cs)
• Duplicated block (7 lines × 8) (src/BasicTTS/FormMainHelpers.cs)
• Duplicated block (7–12 lines × 5) (src/BasicTTS/FormMainHelpers.cs)
• Duplicated block (7–8 lines × 2) (src/ActuarialIntelligence.Domain/Date/DateIncrement.cs)
• Duplicated block (8 lines × 2) (src/ActuarialIntelligence.Domain/Matrix/_mnMatrix.cs)
• Duplicated block (8–12 lines × 2) (src/AI.TTS.EXE/Program.cs)
• …and 93 more

• Unchanged — 14 HTTP endpoints

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

ActuarialIntelligence/Base was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.