Location: Home / Examples

The Examples/ folder at the repository root contains standalone runnable sample projects. These projects reference the main library Vorcyc.Mathematics (targets/dotNET10_Portable) and demonstrate how to use each module's API in real-world scenarios; they are not included in the NuGet package and must be built and run from source.

📒Contents

• 🔖 Directory Layout Convention
• 🔖 Audio_example — NAudio Audio Pipeline
• 🔖 Core_example — Core and ComputingContext
• 🔖 MachineLearning_example — Tabular Learning
• 🔖 Colorization_example — Image Colorization
• 🔖 SignalProcessing_example — Signal Processing
• 🔖 DeepLearning_example — Deep Learning
• 🔖 Calculus_example — Calculus
  • 🔖 Models and Scenarios
  • 🔖 Dependencies
  • 🔖 Export from Legacy HModel
  • 🔖 Command-Line Usage
  • 🔖 Code Structure
  • 🔖 Relationship to the Deep Learning Module

Examples/
└── <example_name>_example/
    ├── <example_name>_example.csproj   # References dotNET10_Portable
    ├── Program.cs                # CLI entry point
    ├── models/                   # Exported .vmdl (optional, copied to output on build)
    └── …                         # Model definitions, serialization, image I/O, etc.

When adding a new example:

1. Create a standalone .csproj under Examples/ with TargetFramework matching the main library (net10.0).
2. Add the project to the /Examples/ folder in Vorcyc.Mathematics.slnx.
3. Append a row to the table on this page and add a corresponding section.

End-to-end demo: NAudio read/write WAV → Vorcyc Signal → MFCC → BatchSequential training/inference. Closer to real projects than the audio command in DeepLearning_example (.wav files on disk rather than in-memory synthesized waves).

# Full pipeline: generate demo WAV → train → analyze → infer
dotnet run --project Examples/Audio_example

dotnet run --project Examples/Audio_example -- prepare
dotnet run --project Examples/Audio_example -- analyze data/class_low/tone_220hz.wav
dotnet run --project Examples/Audio_example -- analyze my.wav --csv mfcc.csv
dotnet run --project Examples/Audio_example -- train --epochs 3000
dotnet run --project Examples/Audio_example -- predict data/class_high/tone_1200hz.wav
dotnet run --project Examples/Audio_example -- help

Data directory (default under output directory bin/.../net10.0/data/):

data/
├── class_low/    # Label low: low-frequency demo tones (replace with your own WAV files)
└── class_high/   # Label high: high-frequency demo tones
models/
└── pitch_mfcc.vmdl   # BatchSequential weights saved after train

Examples/Audio_example/
├── Program.cs
├── PitchClassifierConfig.cs
├── Io/
│   └── WavBridge.cs              # NAudio ↔ Signal (with resampling)
└── Pipeline/
    ├── DemoDataFactory.cs        # Generate 16-bit PCM demo WAV
    ├── LabeledWavDataset.cs      # Load labeled dataset by folder
    ├── MfccFileAnalyzer.cs       # analyze: RMS / FFT / MFCC
    └── PitchClassifierTrainer.cs # train / predict + ModelSerializer

Demonstrates ComputingContext, MatrixFp32.Multiply, Span statistics extensions, and VectorSpan hot-path APIs. No extra NuGet packages; runs cross-platform. Complements the Module_ComputingContext manual.

dotnet run --project Examples/Core_example
dotnet run --project Examples/Core_example -- matrix
dotnet run --project Examples/Core_example -- statistics
dotnet run --project Examples/Core_example -- vector
dotnet run --project Examples/Core_example -- context
dotnet run --project Examples/Core_example -- help

Examples/Core_example/
├── Program.cs
├── MatrixDemo.cs           # MatrixFp32.Multiply + ComputingScope
├── StatisticsDemo.cs       # Sum / Average / StandardDeviation
├── VectorDemo.cs           # Dot / Norm / Axpy
└── ComputingContextDemo.cs # Explicit parameters vs Scope priority

Demonstrates typical 0.9 machine learning module workflows: synthetic three-cluster 2D data, DataSplit partitioning, training and evaluation with multiple IClassifier<double> implementations, ClassificationPipeline, grid search and K-fold cross-validation, plus regression pipeline examples. No extra NuGet dependencies; runs cross-platform.

# Overview (default): classification + regression
dotnet run --project Examples/MachineLearning_example

# Classification only
dotnet run --project Examples/MachineLearning_example -- classify

# Regression: KnnRegressor, RegressionPipeline batch prediction, ridge regression, K-fold CV
dotnet run --project Examples/MachineLearning_example -- regression

dotnet run --project Examples/MachineLearning_example -- help

Examples/MachineLearning_example/
├── Program.cs              # classify / regression CLI
├── BlobDataset.cs          # Three-cluster synthetic classification data
└── RegressionDataset.cs    # Synthetic regression data

For batch inference performance comparison, see `benchmarks/basic_benchmark/MachineLearning_batch_benchmark.cs` (uncomment in `Program.cs` to run).

Full API documentation and copy-paste snippets: Machine Learning Module — 0.9 classifier walkthrough.

Colorizes grayscale or color photos, ported from the NeuralColor / Colorization approach in Vorcyc.AwesomeAI, rewritten with the 0.9 DeepLearning Modules API (Convolution2DLayer, BatchNormLayer, ReLUActivation, etc.) and custom model containers; image I/O uses Emgu.CV.

Both networks use dual-branch or encode-fusion structures that cannot be described by a single BatchSequential, so the sample project implements ColorNetModel / ChromaGanModel; weights are saved via sample-specific serializers as VMDL v3 variants (ModelKind = 4 / 5, see VmdlTensorArchive).

Default paths (overridable on the command line):

• ColorNet: models/Colornet.vmdl, legacy model model_zoo/vision/colorization/Colornet.HModel
• ChromaGAN: models/ChromaGAN.vmdl, legacy model model_zoo/vision/colorization/ChromaGAN.HModel

In addition to the main library, the sample project references:

Runtime must be Windows (Emgu runtime package). On Linux/macOS, replace with the corresponding Emgu runtime or rewrite image I/O.

If you only have .HModel, export to .vmdl first:

cd Examples/Colorization_example

# ColorNet
dotnet run -- export colornet <Colornet.HModel path> models/Colornet.vmdl

# ChromaGAN
dotnet run -- export chromagan <ChromaGAN.HModel path> models/ChromaGAN.vmdl

Export flow: half-precision decode (Legacy/HalfHelper) → populate ColorNetModel / ChromaGanModel Parameter → ColorNetSerializer / ChromaGanSerializer write VMDL.

If the target .vmdl does not exist when running colorize and the corresponding .HModel exists at the default path, the program auto-exports before inference.

# Realistic colorization (ColorNet)
dotnet run --project Examples/Colorization_example -- colorize photo.jpg result.jpg --scenario realistic

# People colorization (ChromaGAN)
dotnet run --project Examples/Colorization_example -- colorize photo.jpg result.jpg --scenario people

# Specify model file
dotnet run --project Examples/Colorization_example -- colorize photo.jpg out.jpg --scenario people --model models/ChromaGAN.vmdl

Command summary

Examples/Colorization_example/
├── Program.cs                 # export / colorize CLI
├── ColorizationEnhancer.cs      # Unified entry (Scenario + model loading)
├── Models/
│   ├── ColorNetModel.cs       # ColorNet forward (Modules API)
│   ├── ChromaGanModel.cs      # ChromaGAN forward
│   ├── SpatialLinearLayer.cs  # GFN / global2 spatial fully connected
│   └── ModelWeightUtils.cs    # Weight copy helpers
├── Legacy/
│   ├── HalfHelper.cs          # half → float
│   ├── HModelReader.cs        # ColorNet HModel
│   └── HModelChromaGanReader.cs
├── Serialization/
│   ├── VmdlTensorArchive.cs   # Shared VMDL tensor read/write
│   ├── ColorNetSerializer.cs  # ModelKind = 4
│   └── ChromaGanSerializer.cs # ModelKind = 5
└── Vision/
    ├── ColorNetIo.cs          # Emgu preprocessing / LAB compositing
    └── ChromaGanIo.cs

Programmatic usage example

using Colorization_example;
using Emgu.CV;

using var enhancer = new ColorizationEnhancer(
    ColorizationEnhancer.Scenario.RealisticView,
    @"models/Colornet.vmdl");

using var input = new Mat(@"photo.jpg");
using var output = enhancer.Colorize(input);
CvInvoke.Imwrite(@"result.jpg", output);

Full training stack documentation: Deep Learning Module. This sample demonstrates inference and legacy weight migration only; to train similar networks, implement Forward / Backward on top of main library containers or extend ModelSerializer.

Demonstrates 0.9 Signal main API: waveform synthesis, TransformToFrequencyDomain, Butterworth low-pass, MfccExtractor (HTK preset), and TremoloEffect. No extra NuGet packages; runs cross-platform.

dotnet run --project Examples/SignalProcessing_example
dotnet run --project Examples/SignalProcessing_example -- synth
dotnet run --project Examples/SignalProcessing_example -- fft
dotnet run --project Examples/SignalProcessing_example -- filter
dotnet run --project Examples/SignalProcessing_example -- mfcc --csv mfcc.csv
dotnet run --project Examples/SignalProcessing_example -- effect
dotnet run --project Examples/SignalProcessing_example -- context
dotnet run --project Examples/SignalProcessing_example -- help

Examples/SignalProcessing_example/
├── Program.cs
├── SynthDemo.cs
├── FftDemo.cs
├── FilterDemo.cs
├── MfccDemo.cs
├── EffectDemo.cs
└── ContextDemo.cs      # GetRms, ParallelComputeFrom(MFCC)

FftDemo and ContextDemo demonstrate ComputingContext / ComputingScope (FFT, RMS, parallel MFCC).

Demonstrates the differentiable training stack: Sequential / BatchSequential + Trainer (XOR, batch XOR, CNN+MLP, MFCC audio classification), computingContext parameters, ModelSerializer v3 round-trip, and MlpRegressor (DeepLearning.Training) curve fitting (y=x^2).

dotnet run --project Examples/DeepLearning_example
dotnet run --project Examples/DeepLearning_example -- xor
dotnet run --project Examples/DeepLearning_example -- classify
dotnet run --project Examples/DeepLearning_example -- batch
dotnet run --project Examples/DeepLearning_example -- cnn
dotnet run --project Examples/DeepLearning_example -- audio
dotnet run --project Examples/DeepLearning_example -- serialize
dotnet run --project Examples/DeepLearning_example -- curvefit
dotnet run --project Examples/DeepLearning_example -- help

Examples/DeepLearning_example/
├── Program.cs
├── XorDemo.cs
├── ClassifyDemo.cs
├── BatchTrainDemo.cs
├── CnnMlpDemo.cs
├── AudioClassifyDemo.cs
├── SerializeDemo.cs
└── CurveFitDemo.cs

Demonstrates numerical integration (trapezoidal / Romberg / Gauss-Legendre), derivatives and gradients, RK4 ODE solving, Newton/Brent root finding, and Taylor / Fourier series.

dotnet run --project Examples/Calculus_example
dotnet run --project Examples/Calculus_example -- integrate
dotnet run --project Examples/Calculus_example -- derivative
dotnet run --project Examples/Calculus_example -- ode
dotnet run --project Examples/Calculus_example -- root
dotnet run --project Examples/Calculus_example -- series
dotnet run --project Examples/Calculus_example -- help

Examples/Calculus_example/
├── Program.cs
├── IntegrationDemo.cs
├── DerivativeDemo.cs
├── OdeDemo.cs
├── RootFindingDemo.cs
└── SeriesDemo.cs