Aspose.OMR for .NET adds optical mark recognition (OMR) functionality to your C#, VB.NET, and ASP.NET applications. With it, you can design, render and recognize all types of hand-filled forms: answer sheets, examination papers, surveys, questionnaires, ballots, applications, and many more. No specialized equipment, consumables and third-party software required. Use your office copier or even a smartphone camera instead of an expensive OMR scanner. Respondents can fill out your forms with a pen, pencil or marker and use any type of marks - artificial intelligence and advanced accuracy calibration ensure reliable results. You can even recognize rotated and skewed images. Aspose.OMR for .NET can recognize any file you get from a scanner or camera: PDF, JPEG, PNG, TIFF, GIF, and BMP. Recognition results are returned in the most popular data storage formats (JSON, XML and CSV) that can be imported into any popular database, CRM or analysis system. Aspose.OMR for .NET supports QR codes and barcodes recognition. Aspose.OMR for .NET offers a flexible markup language for designing OMR forms of any layout and complexity; you can even add QR codes, barcodes and images without using third-party libraries. All popular paper sizes as well as a number of non-standard ones are supported. Forms are saved in multiple file formats, intelligently selected based on the provided extension: PDF, JPEG, PNG, TIFF, GIF, and BMP. Aspose.OMR for .NET is written in C#, has managed code, and supports both x86 and x64 systems. Changelog: - Added support for .NET10 and .NET8.0 - Removed .NET7.0 and .NET6.0 - Fix issue line-ending detection. Now LF and CRLF templates work consistently across any platforms. Check for details at https://releases.aspose.com/omr/net/release-notes/2026/aspose-omr-for-net-26-11-0-release-notes/ Resources: Online documentation: https://docs.aspose.com/omr/net/ Free support forum: https://forum.aspose.com/c/omr/
Foundational classes for financial, engineering, and scientific applications, including complex number classes, general vector and matrix classes, structured sparse matrix classes and factorizations, general sparse matrix classes and factorizations, general matrix decompositions, least squares solutions, random number generators, Fast Fourier Transforms (FFTs), numerical integration and differentiation methods, function minimization, curve fitting, root-finding, linear and nonlinear programming. This package also provides functions for statistical computation and biostatistics, including descriptive statistics, probability distributions, combinatorial functions, multiple linear regression, hypothesis testing, analysis of variance, multivariate statistics, partial least squares, and nonnegative matrix factorization. Built on .NET 8. Requires a minimum of .NET 8. Requires Visual Studio 2015-2019 C++ x64 runtime. Requires x64 hardware.
Foundational classes for financial, engineering, and scientific applications, including complex number classes, general vector and matrix classes, structured sparse matrix classes and factorizations, general sparse matrix classes and factorizations, general matrix decompositions, least squares solutions, random number generators, Fast Fourier Transforms (FFTs), numerical integration and differentiation methods, function minimization, curve fitting, root-finding, linear and nonlinear programming. This package also provides functions for statistical computation and biostatistics, including descriptive statistics, probability distributions, combinatorial functions, multiple linear regression, hypothesis testing, analysis of variance, multivariate statistics, partial least squares, and nonnegative matrix factorization. Built on .NET 8. Requires a minimum of .NET 8. Requires libgcc linux. Requires x64 hardware.
A utility library to calculate work time within a period, with a configurable work schedule, multiple shifts and holidays Time complexity: O(n*k) where n is the maximum number of shifts per day, and k is the number of holidays within a single period
xFunc provides a powerful parser and analyzer for mathematical expressions. It excels at calculating derivatives, simplifying expressions, and achieving high performance.
Features: * The dump output is separated from the targeted dump media by the familiar TextWriter interface. * The programmer can dump the value of any type of object: primitive and enum types (including those marked with FlagsAttribute), custom classes, struct-s, collections, etc. * For complex type objects (classes and structs) the dumper outputs the names and the values of the properties. * The dump is recursive: the complex members of the dumped object are dumped indented. * Dumps the elements of sequences (arrays, lists, dictionaries, etc.) * Handles circular references. * The developers can easily customize various aspects of the dump by using an attribute (DumpAttribute) on the classes and their members, such as: - the order in which the properties are dumped; - formatting of the property names and/or values; - suppressing the dump of some uninteresting properties; - masking the values of sensitive (e.g. PII) properties; - the depth of the recursion into complex members; - the maximum number of dumped elements of sequence properties. * The dumper picks the customization attributes also from buddy classes declared with MetadataTypeAttribute. * Even if the class doesn't have any attributes, the programmer can still pass a metadata class as a separate parameter to the dumping method. This allows for control over the dump of BCL and third party classes. * Built and tested with .NET 4.0, 4.5, 4.5.1. This package targets .NET 4.0.
Foundational classes for financial, engineering, and scientific applications, including complex number classes, general vector and matrix classes, structured sparse matrix classes and factorizations, general sparse matrix classes and factorizations, general matrix decompositions, least squares solutions, random number generators, Fast Fourier Transforms (FFTs), numerical integration and differentiation methods, function minimization, curve fitting, root-finding, linear and nonlinear programming. This package also provides functions for statistical computation and biostatistics, including descriptive statistics, probability distributions, combinatorial functions, multiple linear regression, hypothesis testing, analysis of variance, multivariate statistics, partial least squares, and nonnegative matrix factorization. Built on .NET Standard 2.0. Requires a minimum of .NET Standard 2.0, .NET 5 or .NET Core 2.0. Does not support .NET Framework. Requires Visual Studio 2017 C++ x86 and x64 runtimes. Requires x64 hardware.
Foundational classes for financial, engineering, and scientific applications, including complex number classes, general vector and matrix classes, structured sparse matrix classes and factorizations, general sparse matrix classes and factorizations, general matrix decompositions, least squares solutions, random number generators, Fast Fourier Transforms (FFTs), numerical integration and differentiation methods, function minimization, curve fitting, root-finding, linear and nonlinear programming. If you're using at least .NET Framework 4.6.1 or .NET Core 2.0, we recommend using one of our NMath .NET Standard NuGet packages.
The MathEvaluator .NET library allows you to evaluate and compile any mathematical expressions from a string dynamically. It supports a wide range of operations and allows for the use of custom variables, operators, and functions. The evaluator can be configured for different contexts, such as scientific or programming math expressions, making it highly versatile for various use cases. This flexibility, combined with its high performance, makes it an excellent choice for developers needing a robust mathematical evaluation tool.
Foundational classes for financial, engineering, and scientific applications, including complex number classes, general vector and matrix classes, structured sparse matrix classes and factorizations, general sparse matrix classes and factorizations, general matrix decompositions, least squares solutions, random number generators, Fast Fourier Transforms (FFTs), numerical integration and differentiation methods, function minimization, curve fitting, root-finding, linear and nonlinear programming. This package also provides functions for statistical computation and biostatistics, including descriptive statistics, probability distributions, combinatorial functions, multiple linear regression, hypothesis testing, analysis of variance, multivariate statistics, partial least squares, and nonnegative matrix factorization. Built on .NET Standard 2.0. Requires a minimum of .NET Standard 2.0, .NET 5, .NET Core 2.0 or .NET Framework 4.6.1. Requires x64 hardware. On Windows, requires Visual Studio 2017 C++ x64 runtime. On Linux, requires libgcc.
Numerics.NET is a set of libraries for numerical computing and data analysis. This package provides types specialized to single-precision, including complex numbers, as well as optimized implementations of single-precision linear algebra. Supports .NET 8, 9, 10, 11, .NET Framework 4.6.2+, .NET Standard 2.0 on Windows, Linux and macOS.
Foundational classes for financial, engineering, and scientific applications, including complex number classes, general vector and matrix classes, structured sparse matrix classes and factorizations, general sparse matrix classes and factorizations, general matrix decompositions, least squares solutions, random number generators, Fast Fourier Transforms (FFTs), numerical integration and differentiation methods, function minimization, curve fitting, root-finding, linear and nonlinear programming. This package also provides functions for statistical computation and biostatistics, including descriptive statistics, probability distributions, combinatorial functions, multiple linear regression, hypothesis testing, analysis of variance, multivariate statistics, partial least squares, and nonnegative matrix factorization. Built on .NET Standard 2.0. Requires a minimum of .NET Standard 2.0, .NET 5, .NET Core 2.0 or .NET Framework 4.6.1. Requires x64 hardware.
SimpleLPR is a professional-grade license plate recognition (LPR/ANPR) library that provides automatic detection and reading of vehicle license plates in images and video streams. Developed over 10+ years and deployed in thousands of production systems worldwide, SimpleLPR delivers enterprise-level reliability with a simple, developer-friendly API. **Proven Performance** Achieves 85-95% recognition accuracy under typical conditions (plate text height ≥20 pixels, reasonable image quality). The specialized OCR engine is trained specifically for license plate fonts and formats, handling challenging real-world scenarios including varying lighting, camera angles up to ±30°, and vehicle motion. **Comprehensive Input Support** • Static images: JPEG, PNG, TIFF, BMP from files or memory buffers • Video files: AVI, MP4, MKV and other common formats • Live streams: RTSP, HTTP, and other network protocols • Configurable resolution limits for performance optimization **Advanced Features** • Multi-threaded processor pools enable concurrent analysis of multiple streams • Intelligent plate tracking correlates detections across video frames, reducing false positives • Plate region detection provides exact coordinates and confidence scores • Character-level analysis with individual confidence metrics • Contrast sensitivity adjustment for shadow and glare compensation • Automatic perspective correction for angled plate views • Support for approximately 90 countries with region-specific templates **Developer-Focused Design** SimpleLPR offers native APIs for C++, .NET (C#, VB.NET, F#), and Python, each following platform conventions. The library handles all complexity internally - developers simply provide an image and receive structured results containing the plate text, country, confidence scores, and location coordinates. **Video Processing Capabilities** The video API includes frame extraction, automatic buffering, stream reconnection for network sources, and synchronized result delivery. The plate tracker maintains temporal consistency across frames, eliminating transient misreads common in frame-by-frame processing. **System Requirements** • Windows 10/11 (x64) or Linux Ubuntu 20.04+ (x64) • .NET Standard 2.0 or higher for .NET integration • Python 3.8, 3.9, 3.10, 3.11, 3.12, 3.13, or 3.14 for Python integration • Optional: CUDA-capable GPU for performance boost (SDK version) **Licensing** 60-day evaluation included. Production license is one-time purchase with unlimited, royalty-free redistribution rights. Includes one year of technical support and updates. **Resources** • Project Site: https://www.warelogic.com • Documentation: https://www.warelogic.com/doc/SimpleLPR3.pdf • .NET API Reference: https://www.warelogic.com/doc/SimpleLPR.chm • Python API Reference: https://www.warelogic.com/doc/simplelpr_python_api_reference.htm • Python Quick Start: https://www.warelogic.com/doc/simplelpr_python_quickstart_guide.htm • Sample Code: https://github.com/xgirones/SimpleLPR-samples • Support: support@warelogic.com See the project README for complete documentation and code examples.
Aspose.OMR for C++ adds optical mark recognition (OMR) functionality to your applications. With it, you can design, render and recognize all types of hand-filled forms: answer sheets, examination papers, surveys, questionnaires, ballots, applications, and many more. No specialized equipment, consumables and third-party software required. Use your office copier or even a smartphone camera instead of an expensive OMR scanner. Respondents can fill out your forms with a pen, pencil or marker and use any type of marks - artificial intelligence and advanced accuracy calibration ensure reliable results. You can even recognize rotated and skewed images. Aspose.OMR for C++ can recognize any file you get from a scanner or camera: JPEG, PNG, TIFF, GIF, and BMP. Recognition results are returned in the most popular data storage formats (JSON and CSV) that can be imported into any popular database, CRM or analysis system. Aspose.OMR for C++ supports QR codes and barcodes recognition. Aspose.OMR for C++ offers a flexible markup language for designing OMR forms of any layout and complexity; you can even add QR codes, barcodes and images without using third-party libraries. All popular paper sizes as well as a number of non-standard ones are supported. Forms are saved in multiple file formats, intelligently selected based on the provided extension: JPEG, PNG, TIFF, GIF, and BMP. Changelog: - The library now works correctly in debug mode. - Resolved licensing module errors. - Improved JSON serialization/deserialization. - Minor improvements and fixes. Resources: Online documentation: https://docs.aspose.com/omr/cpp/ Free support forum: https://forum.aspose.com/c/omr/
PDFFlow is a cross-platform C# library for creating PDF documents. The library is based on C# port the well-known libHaru. With PDFFlow, you can create complex PDF documents fast and efficiently - you define documents as a set of layout rules and a sequence of paragraphs, tables, images, headers, etc. and the library does all the work to create a PDF document by applying the layout on the content stream. You can create agreements, contracts, log books, invoices, tickets, catalogs, brochures, complex tax and regulatory forms, medical documents, school and university tests, books and magazines and many other kinds of documents. Your documents can include: - Text with different formatting, including special fields such as page numbers and URLs, and widow and orphan control. - Built-in Base14 fonts, multibyte CID fonts, external TrueType and Type1 fonts, single-byte and multibyte encodings. - Multilevel lists with easy-to-use styles. - Tabulations. - Images with configurable size and scaling. - Lines, both vertical and horizontal. - Tables taking data from a data source, with colspan and rowspan. - Multi-page and book spread tables. - Repeating areas: multiple headers, footers, left and right repeating areas, and repeating areas by coordinates. - Document flow areas that define the location of the document main flow on the pages. - Automatically generated table of content. PDFFlow supports automatic pagination and layouting: the content is automatically continued on the next page if it does not fit in the current page. You can configure any formatting settings of your document and its elements: fonts, colors, alignment, borders, indents, stroke styles, etc. as you need. This can be done using the corresponding methods in each case or through styles - you create your styles and apply them to quickly get the necessary formatting. The PDFFlow library is supplied with real document samples accompanied by descriptive articles and tutorials with many working code examples that can be used as is or modified, and the API reference. The included license allows you to use the library for free: - In any open source or non-commercial project or products. - To prototype, develop, and test commercial projects or products. The commercial license is required to use the library in commercial projects on the production stage (including the products used to support the internal business). Review the licences available at https://www.pdfflow.io/licensing or contact Gehtsoft USA LLC sales representative to get details about the licensing. Examples and tutorials: https://github.com/gehtsoft-usa/PDF.Flow.Examples Online documentation: http://docs.gehtsoftusa.com/pdfflow/web-content.html
The package provides code analysis features using the Roslyn CTP. The project calculates the following metrics: Project Level - Cyclomatic Complexity - LinesOfCode - Maintainability Index - Project Dependencies - Type Couplings - Abstractness - Afferent Coupling - Efferent Coupling - RelationalCohesion Namespace Level - Cyclomatic Complexity - LinesOfCode - Maintainability Index - Project Dependencies - Type Couplings - Depth of Inheritance - Abstractness Type Level - Cyclomatic Complexity - LinesOfCode - Maintainability Index - Project Dependencies - Type Couplings - Depth Of Inheritance - Type Coupling - Afferent Coupling - Efferent Coupling - Instability Member Level - Cyclomatic Complexity - Lines Of Code - Maintainability Index - Project Dependencies - Type Couplings - Number Of Parameters - Number Of Local Variables - Afferent Coupling - Halstead Metrics
Dew.Math is the Windows-optimized high-performance numerical computation library for .NET. It provides a vectorized matrix and vector math environment with native runtime acceleration, multithreaded execution, and extensive algorithm libraries for scientific, engineering, financial, AI/ML and signal processing workloads. Core Numerical Capabilities: - Dense linear algebra (BLAS, LAPACK): SVD, QR, LQ, LU, eigenvalue problems, least-squares, rank reveals - Sparse matrix support: direct solvers (Pardiso, UMFPACK), iterative solvers (CG, BiCG, GMRES), preconditioning strategies, structured sparse formats - Complex number computation with fully vectorized math operations - Polynomial arithmetic, interpolation, splines, rational approximations, Chebyshev basis transforms - Numerical differentiation, root solving, non-linear systems, ODE support for stiff and non-stiff cases - Probability distributions (over 30 families), random number generators, Monte Carlo methods - Special mathematical functions (Airy, Bessel, Gamma-related, elliptic integrals, Legendre, etc.) Optimization and Modeling: - Non-linear curve fitting with Levenberg-Marquardt and trust-region refinements - Direct and constrained optimization (Simplex/Nelder–Mead, BFGS, Conjugate Gradient, LP, dual-phase simplex, Gomory cutting plane) - Vectorized expression parser for dynamic formula construction and symbolic-style evaluation Performance Architecture: - Native accelerated BLAS/LAPACK kernels with automatic CPU dispatch (AVX, AVX2, AVX-512) - Scalable multithreading with a lock-free memory allocator for low-GC overhead - Optional OpenCL GPU offloading for supported device targets Platform Model: - Contains Windows native acceleration binaries - For Linux native acceleration use: Dew.Math.Linux - For a pure managed, portable edition use: Dew.Math.Core Use Dew.Math when you require **maximum numerical performance on Windows** for HPC, simulation, economic modeling, data analytics, or scientific visualization workflows.
🧬 One-touch unmanaged memory, libraries, executable modules, runtime dynamic use of the unmanaged native C/C++ in .NET world, related P/Invoke features, and ... Even accessing to complex types like structures without their declaration at all. ## Why Conari ? It was designed to be loyal to your needs on the fly! 🧰 Powerful types ``` using dynamic l = new ConariX("regXwild.dll"); string data = "number = 888;"; bool found = l.replace<bool>(ref data, "+??;", "2034;"); // found: true; data: number = 2034; ``` 🔨 Its amazing DLR features Conari will generate and adapt everything at runtime! Specially for you! 🔧 The easiest (most ever) access to any data in unmanaged memory ``` ptr.Native().f<int>("x", "y").build(out dynamic l); l.x // 17 l.y // -23 ``` 🏄 Most powerful PInvoke and even most convenient use of WinAPI without preparing something For example, below we don't provide neither *user32.ShowWindow()* nor *user32.MessageBoxA(),* even no *kernel32.GetModuleHandleA/W()* ``` dynamic user32 = new User32(); user32.ShowWindow(0x000A0A28, 3); user32.MessageBoxA(0, "Conari in action", "Hello!", 0); ``` 🚀 Awesome speed test of regXwild's algorithms [[340x10000 Unicode](https://github.com/3F/regXwild#speed)] 🍰 MIT License! Enjoy. . . . Read more: https://github.com/3F/Conari _ _ _ _ _ _ ======================================= gnt /p:ngpackages="Conari/1.5.0" ================== https://github.com/3F/GetNuTool Conari 1.5.0.63141+ba1a82e Configuration: PublicRelease Platforms: net40;net472;netcoreapp2.1;net5;netstandard2.0;netstandard2.1 :: generated by a vsSolutionBuildEvent 1.14.1.34071
EvoPdf Next HTML to PDF Converter for .NET (Multi-platform) uses a highly accurate and reliable Chromium-based rendering engine to process modern and complex HTML, CSS and JavaScript content in compliance with the latest standards. The converter targets .NET Standard 2.0 and can be used in .NET Core and .NET Framework applications deployed on Windows, Linux and macOS, including Azure, AWS, Google Cloud, Docker and Kubernetes. This multi-platform metapackage installs the Windows x64 and Linux x64 runtimes. For Windows ARM64, Linux ARM64 and macOS ARM64, the additional packages EvoPdf.Next.HtmlToPdf.Windows.Arm64, EvoPdf.Next.HtmlToPdf.Linux.Arm64 and EvoPdf.Next.HtmlToPdf.MacOS can be referenced on their own or alongside this package. Compatibility: * Windows 10, 11 and Windows Server 2016 to 2025 (x64) * Linux (x64) - Debian 11+, Ubuntu 20.04+ or equivalent * Windows, Linux and macOS (ARM64) - via additional packages * .NET 11.0, 10.0, 9.0, 8.0, 7.0, 6.0 and .NET Standard 2.0 * .NET Framework 4.6.2 to 4.8.1 * Azure, AWS and Google Cloud * Virtual Machines * Docker containers and Kubernetes * Web, Console and Desktop applications Main Features: * Convert HTML with CSS, web fonts and JavaScript to PDF * Support modern web standards and technologies * Generate PDF/UA and PDF/A compliant documents * Add HTML with page numbers in headers, footers and stamps * Repeat HTML table headers and footers in PDF pages * Control PDF page breaks with CSS in HTML * Create outlines and tables of contents from heading tags * Convert HTML forms to interactive PDF forms * Convert or exclude specific HTML regions * Retrieve HTML element positions in the PDF * Trigger conversion automatically or manually * Render for screen or print media * Set PDF security, viewer settings and signatures * Set HTTP headers and cookies * Use GET and POST requests * Convert HTML to images * Convert SVG to PDF * Asynchronous methods for async/await
Foundational classes for financial, engineering, and scientific applications, including complex number classes, general vector and matrix classes, structured sparse matrix classes and factorizations, general sparse matrix classes and factorizations, general matrix decompositions, least squares solutions, random number generators, Fast Fourier Transforms (FFTs), numerical integration and differentiation methods, function minimization, curve fitting, root-finding, linear and nonlinear programming. This package also provides functions for statistical computation and biostatistics, including descriptive statistics, probability distributions, combinatorial functions, multiple linear regression, hypothesis testing, analysis of variance, multivariate statistics, partial least squares, and nonnegative matrix factorization. Built on .NET Standard 2.0. Requires a minimum of .NET Standard 2.0, .NET 5, .NET Core 2.0 or .NET Framework 4.6.1. Requires Visual Studio 2017 C++ x86 runtime.
Dew.Math.Linux provides the high-performance numerical computation capabilities of Dew.Math, but with native acceleration binaries compiled for Linux. It is designed for compute clusters, scientific servers, containerized deployment environments, and performance-critical Linux workloads. Core Numerical Capabilities: - Dense linear algebra (BLAS/LAPACK): decomposition and eigenvalue routines optimized for AVX/AVX-512 - Sparse matrix operations with Pardiso and UMFPACK direct solvers and Krylov-based iterative solvers - Complex-valued linear algebra and spectral computations - Polynomial operations, splines, interpolation, approximate function models, and spectral transforms - Probability distributions, stochastic simulation, and random number engines - Special function library suitable for numerical physics, statistics, and differential systems - Optimization algorithms for non-linear fitting, gradient models, linear programming, and statistical inference Performance Architecture: - Linux-native accelerated BLAS/LAPACK libraries - Multithreaded vectorized math with CPU feature dispatch (AVX/AVX2/AVX-512) - Low-overhead memory allocator for stable scaling under parallel workloads - Optional OpenCL GPU integration for Linux compute environments Platform Model: - Contains Linux native runtime binaries - For Windows native acceleration use: Dew.Math - For portable managed-only computation use: Dew.Math.Core Use Dew.Math.Linux for Linux HPC compute nodes, microservice model engines, AI research pipelines, and scalable distributed scientific processing.
Armadillo is a high quality linear algebra library (matrix maths) for the C++ language, aiming towards a good balance between speed and ease of use Provides high-level syntax (API) deliberately similar to Matlab Useful for algorithm development directly in C++, or quick conversion of research code into production environments (eg. software & hardware products) Can be used for machine learning, pattern recognition, computer vision, signal processing, bioinformatics, statistics, finance, etc Provides efficient classes for vectors, matrices and cubes, as well as 200+ associated functions; integer, floating point and complex numbers are supported Various matrix decompositions are provided through integration with LAPACK, or one of its high performance drop-in replacements (eg. multi-threaded Intel MKL, or OpenBLAS) A sophisticated expression evaluator (based on template meta-programming) automatically combines several operations to increase speed and efficiency Available under a permissive license, useful for both open-source and proprietary (closed-source) software
TooString is a Stringifier that goes places serializers don't. TooString can - make a best effort to stringify objects that JsonSerializer won't, including System.Reflection classes and System.Type; or for which JsonSerializer returns empty output, such as ValueTuples. - Output as Json or C# object notation, or 'debug view' style, or [CallerArgumentExpression] TooString offers 5 extension method groups on Object: ```csharp value.ToCSharpString() value.ToJson(); value.ToSTJson() value.TooString(); value.ToCallerArgumentExpression(); ``` _TooString is not a serializer._ - TooString offers both maxDepth and maxEnumerableLength options for abbreviated output. - TooString defaults to maxDepth = 3, maxEnumerableLength = 9. - A serializer should be fail-fast: a Serializer should throw if it cannot deterministically serialize the input, but TooString will attempt to return a partial representation of the input if the input cannot be reliably serialized. Example: ``` var value = new { A = "boo", B = new Complex(3,4) }; value.ToCSharpString() // Output is { A = "boo", B = <3; 4> } depending on .Net version. value.ToJson(); // Output is JSON: {"A":"boo","B":[3,4]} value.ToSTJson(); // Output is System.Text.Json: {"A":"boo","B":{"Real":3,...}} ( Math.Sqrt(4 * Math.PI / 3) ).ToCallerArgumentExpression() // Output is the literal code: "Math.Sqrt(4 * Math.PI / 3)" var tuple = (one: 1, two: "2", three: new Complex(3,4)); System.Text.Json.JsonSerializer.Serialize(tuple) // Output is "{}" because there // are no public properties on a tuple tuple.ToJson() // Output stringifies the tuple and the Complex number as arrays // [1,"2",[3,4]] tuple.ToCSharpString() // Output is created by reflection and // on Net6.0 : (1, "2", (3,4)) // on Net8.0+: (1, "2", <3;4>) var type = value.GetType(); System.Text.Json.JsonSerializer.Serialize(type) // Throws NotSupportedException type.ToJson() // Outputs the type object, truncated to default MaxDepth = 3, MaxEnumerationLength = 9 ```
MoreComplexDataStructures is a class library containing a collection of data structures (plus related utility classes) more complex than those found in the standard .NET framework. The project currently contains the following data structures and utility classes... WeightBalancedTree<T> - A weight-balanced binary search tree MinHeap<T> - A tree-based min heap MaxHeap<T> - A tree-based max heap PriorityQueue<T> - A tree-based double-ended priority queue Trie<T> - A trie (or prefix tree) CharacterTrie - A trie which stores characters (with some performance enhancements over Trie<Char>) WeightedRandomGenerator<T> - A weighted random number (or item) generator UniqueRandomGenerator - A random number generator guaranteed to always produce unique numbers within a given range FrequencyTable<T> - A frequency table LRUCache<TKey, TValue> - A simple least recently used cache UnflaggedNumberGenerator - Allows the 'flagging' (marking) of numbers in a specified range, and provides methods to identify numbers which were not flagged LongIntegerStatusStorer - Stores a boolean status for a complete set of long integers ListRandomizer - Randomizes the elements of a list using the Fisher/Yates/Knuth algorithm
LongCalcNetCore Arbitrary Precision Float and Complex Number Library
HiQPdf Next HTML to PDF Converter for .NET (Multi-platform) uses a highly accurate and reliable Chromium-based rendering engine to process modern and complex HTML, CSS and JavaScript content in compliance with the latest standards. The converter targets .NET Standard 2.0 and can be used in .NET Core and .NET Framework applications deployed on Windows, Linux and macOS, including Azure, AWS, Google Cloud, Docker and Kubernetes. This multi-platform metapackage installs the Windows x64 and Linux x64 runtimes. For Windows ARM64, Linux ARM64 and macOS ARM64, the additional packages HiQPdf.Next.HtmlToPdf.Windows.Arm64, HiQPdf.Next.HtmlToPdf.Linux.Arm64 and HiQPdf.Next.HtmlToPdf.MacOS can be referenced on their own or alongside this package. Compatibility: * Windows 10, 11 and Windows Server 2016 to 2025 (x64) * Linux (x64) - Debian 11+, Ubuntu 20.04+ or equivalent * Windows, Linux and macOS (ARM64) - via additional packages * .NET 11.0, 10.0, 9.0, 8.0, 7.0, 6.0 and .NET Standard 2.0 * .NET Framework 4.6.2 to 4.8.1 * Azure, AWS and Google Cloud * Virtual Machines * Docker containers and Kubernetes * Web, Console and Desktop applications Main Features: * Convert HTML with CSS, web fonts and JavaScript to PDF * Support modern web standards and technologies * Generate PDF/UA and PDF/A compliant documents * Add HTML with page numbers in headers, footers and stamps * Repeat HTML table headers and footers in PDF pages * Control PDF page breaks with CSS in HTML * Create outlines and tables of contents from heading tags * Convert HTML forms to interactive PDF forms * Convert or exclude specific HTML regions * Retrieve HTML element positions in the PDF * Trigger conversion automatically or manually * Render for screen or print media * Set PDF security, viewer settings and signatures * Set HTTP headers and cookies * Use GET and POST requests * Convert HTML to images * Convert SVG to PDF * Asynchronous methods for async/await
A pseudo-random number generator that allows for quasi-random access, arbitrarily large seeds and arbitrarily-complex mutations from number to number. No attention has been paid to whether or not this is cryptographically-secure. The intention is to support procedural generation of content in video games.
Dew.Math.Core is the portable, pure managed edition of the Dew.Math library. It provides the same high-level matrix and vector programming model, expression parser, probability and optimization toolkit, and special function support without linking to any native runtime components. This enables maximum compatibility across platforms and runtime environments. Core Numerical Capabilities (Managed): - Dense matrix and vector operations with operator overloading and method-based APIs - QR, LU, SVD and eigenvalue routines using high-quality managed linear algebra kernels - Complex number and real-valued computation with full vectorization in managed code - Sparse matrix representations with iterative solver support - Probability distributions, histogramming, random generators, Monte Carlo workflows - Nonlinear optimization, curve fitting, regression models, trust-region and gradient methods - Vectorized expression parsing for symbolic-style expression and simulation pipelines - Polynomial and spline interpolation, numerical integration and differentiation - Special function suite including Bessel, Airy, Gamma-related, Legendre and elliptic functions Portability Model: - No native libraries required (zero unmanaged dependencies) - Runs on Windows, Linux, macOS, iOS, Android, MAUI, Uno, WASM, Unity*, cloud functions and plugins - Targets netstandard2.0, net8.0, and net9.0 Use Dew.Math.Core when you need **maximum portability** in libraries, shared simulation engines, tooling, mobile deployments, WebAssembly environments, or plugin architectures.
The Extreme Optimization Numerical Libraries for .NET are a set of libraries for numerical computing and data analysis. This package provides types specialized to single-precision, including complex numbers, as well as optimized implementations of single-precision linear algebra. Supports .NET 6.0, .NET 5.0, .NET Framework 4.62+, .NET Standard 2.0, and .NET Core 3.1 on Windows, Linux and Mac.
Winnovative Next HTML to PDF Converter for .NET (Multi-platform) uses a highly accurate and reliable Chromium-based rendering engine to process modern and complex HTML, CSS and JavaScript content to the latest standards. The converter targets .NET Standard 2.0 and can be used in .NET Core and .NET Framework applications deployed on Windows, Linux and macOS, including Azure, AWS, Google Cloud, Docker and Kubernetes. This multi-platform metapackage installs the Windows x64 and Linux x64 runtimes. For Windows ARM64, Linux ARM64 and macOS ARM64, the additional packages Winnovative.Pdf.Next.HtmlToPdf.Windows.Arm64, Winnovative.Pdf.Next.HtmlToPdf.Linux.Arm64 and Winnovative.Pdf.Next.HtmlToPdf.MacOS can be referenced on their own or alongside this package. Compatibility: * Windows 10, 11 and Windows Server 2016 to 2025 (x64) * Linux (x64) - Debian 11+, Ubuntu 20.04+ or equivalent * Windows, Linux and macOS (ARM64) - via additional packages * .NET 11.0, 10.0, 9.0, 8.0, 7.0, 6.0 and .NET Standard 2.0 * .NET Framework 4.6.2 to 4.8.1 * Azure, AWS and Google Cloud * Virtual Machines * Docker containers and Kubernetes * Web, Console and Desktop applications Main Features: * Convert HTML with CSS, web fonts and JavaScript to PDF * Support modern web standards and technologies * Generate PDF/UA and PDF/A compliant documents * Add HTML with page numbers in headers, footers and stamps * Repeat HTML table headers and footers in PDF pages * Control PDF page breaks with CSS in HTML * Create outlines and tables of contents from heading tags * Convert HTML forms to interactive PDF forms * Convert or exclude specific HTML regions * Retrieve HTML element positions in the PDF * Trigger conversion automatically or manually * Render for screen or print media * Set PDF security, viewer settings and signatures * Set HTTP headers and cookies * Use GET and POST requests * Convert HTML to images * Convert SVG to PDF * Asynchronous methods for async/await
A commandline parser supporting direct method calls taking as input an unlimited number of primitive and complex-type parameters
* Perform basic and more complex calculations with Fractions. * Convert different units (length, speed, mass, area, volyme), and numeral systems. * Include Coordinates to perform simple and more advanced calculations such as Slope, MidPoint, Distance. * Perform calculations with geometrical shapes (2 dimensional), such as Circles, Squares, Rectangles, Triangles, Parallelograms, Trapezoids, Cubes and also (3 dimensional), Spheres, Square pyramids, Rectangular prisms, Right circular cones and Right circular cylinders. * Use the Mathos's Syntax, to calculate with less code typing. * Make financial calculations. * Work with Uncertain Numbers. * And of course, there are lots of other cool features available in Mathos!
Duality is a plugin based games development framework designed to be a minimal interface into which more specific or complex packages are "plugged in". Since Vorbis is used as Duality's primary audio compression mechanism, it has built in support for importing OGG Vorbis files. It does not provide any mechanism to load or save any other audio file formats. This project aims to extend the number of audio formats supported by implementing an editor plugin which fits into Duality's asset importing workflow. Simply drag new audio files into Duality's Project View.
ADN.Extensions is a cross-platform open-source library which provides helpers and utilities to .NET developers
One exact hologram holds many items at once, and one pass applies a weighted sum of operators to all of them. A Pleroma stores items (a key, and optionally a flag word, an arrangement and a tick) as exact counts in one fixed array, reads exact counts by key, whole item, flag word, arrangement and tick (joint counts over faces are opt-in), and refuses past its key capacity rather than answering wrongly. Relabelling, ageing, diffusion, key shifts and binding two stores act on every stored item in one pass, and flag flips, arrangement relabellings and time shifts summed into a PleromaKernel apply in one pass. The same store backs an aggregate plane for database queries and a page store with parity repair and restore points; CycleHologram adds exact multiset reconciliation between replicas. PleromaArrangementBand holds arrangements of any number of things (ranked ballots) and answers every question on up to a chosen number of places exactly, with a check built into its cells. PleromaFlagBand holds words of up to 64 flags (survey answers, feature flags) and answers every question on up to a chosen number of flags exactly. Every store carries two upper bounds, Mass and Peak, that each operation moves by its own rule, so ReadsCertified and InnerProductCertified prove a read or a join count exact without a pass over the data. KeyedSummary holds an exact 64-bit count and a 128-bit sum per measure for each dense key, with all-or-nothing batches, a one-pass fold through a key-to-group map, exact top-k, pre-grouped group totals that stay exact as facts arrive and as keys change groups, and checksummed persistence; Crc32C is the CRC-32C checksum it uses, hardware-accelerated where the CPU has the instruction. Beneath it all is the phasor Vector Symbolic Architecture (VSA) codec: bind, unbind, bundle and correlate over unit-complex faces, with a frozen-identity codec for models and a width-configurable SIMD codec for storage and similarity search. No dependencies beyond System and System.Numerics.
Arbitrary precision complex (imaginary) numbers.
Set of simple mathematical classes in (Vectors, Matrixes, Polynoms, Systems of linear equations, Integrals methods, Complex numbers, Rational numbers, Graphs, Methods for solving differential equations) + some features such as memoize (function values memorising). Набор простых математических классов: векторы, матрицы, полиномы, комплексные числа, методы решения СЛАУ, интегрирование, поиск минимумов (в том числе алгоритм роя частиц), мемоизация и небольшие фичи.
The Cell framework provides a mechanism to declare a number of values and calculations like cells of a spreadsheet and have them background evaluated automatically in parallel whenever a value changes. Cells can be constructed with closures or profiled the first time they are evaluated, but will always be re-evaluated when a referenced cell has changed (and not otherwise). The Cell framework is designed for complex financial calculations that depend on ticking market data for pricing and real-time risk – where you can not determine which value is going to change for second to second. Cells can be grouped into a Model to encapsulate the implementation of the model in an obj that is IObserver<> for upstream values and IObservable<> for downstream values
The MathEvaluator.FastExpressionCompiler .NET library allows you to evaluate and compile any math expressions from a string dynamically. It supports a wide range of operations and allows for the use of custom variables, operators, and functions. The evaluator can be configured for different contexts, such as scientific or programming math expressions, making it highly versatile for various use cases. This flexibility, combined with its high performance, makes it an excellent choice for developers needing a robust mathematical evaluation tool. Extended with the FastExpressionCompiler's CompileFast() methods, it is 10-40x faster than the traditional Compile() method.
Advanced mathematical expression evaluator including complex numbers, matrices, defining custom variables and functions, API for extensibility, and more.
`QuantumSuperposition` is a .NET library that introduces quantum mechanics-like superpositions into C#. Inspired by concepts in quantum computing, it allows developers to work with scalar values as if they are in multiple states simultaneously. This library is useful for advanced logical and mathematical operations, where parallelism and state superposition can simplify complex computations.
A generic arithmetic library. Allows you to perform arithmetic on any numeric type. All .NET numeric value types are supported, as is any custom numeric type--just implement the numeric operator overloads.
Armadillo is a high quality linear algebra library (matrix maths) for the C++ language, aiming towards a good balance between speed and ease of use Provides high-level syntax (API) deliberately similar to Matlab Useful for algorithm development directly in C++, or quick conversion of research code into production environments (eg. software & hardware products) Can be used for machine learning, pattern recognition, computer vision, signal processing, bioinformatics, statistics, finance, etc Provides efficient classes for vectors, matrices and cubes, as well as 200+ associated functions; integer, floating point and complex numbers are supported Various matrix decompositions are provided through integration with LAPACK, or one of its high performance drop-in replacements (eg. multi-threaded Intel MKL, or OpenBLAS) A sophisticated expression evaluator (based on template meta-programming) automatically combines several operations to increase speed and efficiency Available under a permissive license, useful for both open-source and proprietary (closed-source) software
Framework-agnostic core of the MathAssertions package family. Math assertion helpers for .NET tests, spanning tolerance comparisons (scalar / Vector2-4 / Quaternion + rotational equivalence / Matrix4x4 / Plane + geometric equivalence / Complex / ReadOnlySpan and ReadOnlyTensorSpan / ULP-distance / relative+absolute combined), Sequences (monotonicity / boundedness / progressions / convergence), Statistics (Welford's mean+variance / median / percentile / sigma bounds), LinearAlgebra (matrix invariants and vector pair properties), NumberTheory (long-integer predicates), and Geometry3D (eight primitive types with property predicates / containment / closest-point distance / intersection / pointcloud aggregates). NaN-aware, infinity-aware, AOT-compatible. Test-framework-specific entry points live in adapter packages, starting with MathAssertions.TUnit.
TUnit-native math assertions for .NET tests. Fluent .Method(...) entry points (generated via TUnit's [GenerateAssertion]) covering tolerance comparisons (scalar, vector, quaternion, matrix, plane, complex, double[]/float[]), sequences, statistics, Vector3 linear algebra, long-integer number theory, and the Geometry3D primitive surface (containment, distance, intersection, pointcloud aggregates). Extensible: consumers add tolerance assertions for their own domain types via [GenerateAssertion] extensions calling MathTolerance helpers. AOT-compatible, trimmable, no reflection.