Hjelpemetoder og utvidelser for GML og geometrier til DiBK.RuleValidator
Implementation of the Italian rules for validating Digital Green Certificates. This provider is included in the list of verified SDKs by Italian authorities
Can convert CSharpMath.Atom.MathList parsed from LaTeX with CSharpMath.Atom.LaTeXParser into actual mathematical expressions that are evaluatable with AngouriMath. Supports arithmetic, trigonometry, symbolic simplification and expansion, as well as matrices, sets, and equation solving.
The evaluation engine provides an infrastructure for decoupled evaluation. Features: * The evaluation engine provides a single entry point to ask questions (queries, calculations, ...) * Questioner is completely decoupled from answer finding algorithm. * Hierarchical evaluation engines (children inherit knowledge from parent) * Solution definitions can be loaded from modules or plug-ins. * Extensible to solve any kind of question (validation rules, status queries, …) * Fluent definition syntax allowing constraints, strategies, aggregators and multiple expressions per question. * Thorough customizable logging. bbv.Common.EvaluationEngine is a part of bbv.Common, a library of .NET components and functionality including: * (a)synchronous notification component with thread switching using publisher-subscriber pattern, * hierarchical state machine with fluent definition syntax, * programmatic, loosely coupled, context based rule engine, * support for active objects to build multi-threaded applications
Albatross.Expression api is created to process and evaluate text based expression strings. The api tokenizes the expression text and create a tree model from the tokens. Using the model, it can evaluate the expression or convert it to a expression of different format. Some applications revert the process by creating the model first and using it to generate certain expression such as a sql query statement. The api also contains a useful ExecutionContext class that allows evaluation of expressions with variables. The variables can be read internally or directly from external objects.
Simple expression evaluator for C#
The HTTP Read-Eval-Print Loop (REPL) is a lightweight, cross-platform command-line tool that's supported everywhere .NET Core is supported and is used for making HTTP requests to test ASP.NET Core web APIs and view their results.
Expr Eval (expr-eval) binding library for Bridge.NET projects.
Static Eval (static-eval) binding library for Bridge.NET projects.
FluentSharp is an API that dramatically simplifies the use of .NET Framework APIs. It makes extensive use of .NET ExtensionMethods and it reduces the amount of code required. This is the FluentSharp REPL which provides a C# REPL enviroment (REPL is Read Eval Print Loop) which allows for real-time execution of complex C# code (and GUI manipulation)
Expression are provided as raw string. It enables you to evaluate easily: logical (Or, And and Not), comparison or calculation (+, -, *, /) in an application. Possible to use variable and function call. The component is configurable: double decimal separator, string tag,...
Shared judge harness: a deterministic gate, a rubric-scoring judge, and a two-family panel vote with a tie-break arbiter, over a versioned rubric.
Compile and execute C# code at program runtime
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.
Enable seamless execution of LLM (Large Language Model) evaluations using Semantic Kernel. This library provides tools and abstractions for running automated assessments where LLMs serve as judges, offering structured, consistent, and scalable evaluation methods. Ideal for AI-driven projects that require evaluative feedback, scoring, or comparative analysis across various use cases. Easily integrates with Semantic Kernel for smooth, flexible LLM operations in .NET environments.
STAF.LLMEval is a .NET library and AI testing framework for evaluating LLM and GenAI responses in unit tests and CI/CD. Score AI outputs with pluggable metrics (exact, keyword, TF-IDF or embeddings semantic similarity, JSON/schema validation, relevance, heuristic grounding), LLM-as-judge, and RAG groundedness / hallucination detection. Includes fluent Eval API, rich assertions, Options/DI, JSON/JSONL/CSV evaluation suites, golden baseline comparison, opt-in run-history HTML trends, STAF-style HTML/JSON/Markdown/CSV reports, GitHub Actions / Azure DevOps CI templates, BenchmarkDotNet hot-path suite, and contributor docs. Works with OpenAI, Azure OpenAI, Google Gemini, Ollama, Anthropic Claude, Groq, and Mistral on .NET 8/9/10. This package contains the evaluation assemblies. Optional add-on: STAF.LLMEval.SemanticKernel.
Required binary package for using JavaScript.Eval on Windows.
Matheval is a mathematical expressions evaluator library for .NET. Allows to evaluate mathematical, boolean, string and datetime expressions on the fly. Official document and usage examples: https://matheval.org/math-expression-eval-for-c-sharp/
Write Linq With Eval - Convert string expressions to LINQ expressions dynamically. Supports nullable types, complex expressions, two-parameter lambdas, and comprehensive string operations.
A simple library to parse strings into expressions and then evaluate it on a source object.
C# expression parsing and execution library. Designed for AOT runtimes (Unity's IL2CPP, .NET Native, Mono AOT).
Library that can parse equations and recognize user functions and user variables
The generic eval-harness substrate: provenance stamps for published figures, the model-provider seam with its fake-replay posture, and the demand-census engine generic over a domain seam. No gate, no domain vocabulary, no dependency beyond FSharp.Core.
Build up Security Headers in a (semi) modular way. To use in an ASP.Net Core web project. In startup.cs - add the following private members to the startup class private SecurityHeaders _securityHeaders { get; set; } private List<CspFrame> _cspFrames { get; set; } And the following two private methods (and alter as you need to). These do reference the samples nuget package. private List<CspFrame> AssembleContentSecurityPolicies() { var defCspFrame = new CspFrame().Initialise("default"); defCspFrame.Clauses .AddUpdateClause("script-src", "", "'unsafe-eval'") .AddUpdateClause("style-src", "", "'unsafe-inline'") .AddUpdateClause("img-src", "", "data:") .AddUpdateClause("plugin-types", "", "application/pdf") .AddUpdateClause("frame-ancestors", "", "'none'") .AddUpdateClause("report-uri", "", "/cspreport"); var basicCdnCspFrame = new CspFrame().Initialise("basicCdn"); basicCdnCspFrame.Clauses .AddUpdateClause("default-src", "", "https://maxcdn.bootstrapcdn.com/") .AddUpdateClause("script-src", "", "https://ajax.googleapis.com/ https://code.jquery.com/ https://cdnjs.cloudflare.com/") .AddUpdateClause("style-src", "", "https://fonts.googleapis.com/") .AddUpdateClause("font-src", "", "https://fonts.gstatic.com/") .AddUpdateClause("img-src", "", "https://csi.gstatic.com/"); var googleMapsCspFrame = new CspFrame().GoogleMaps(); var stripeCspFrame = new CspFrame().Stripe(); return new List<CspFrame> { defCspFrame, basicCdnCspFrame, googleMapsCspFrame, stripeCspFrame }; } /// <summary> /// Returns a merged copy of all relevant CspFrames - adding in the Dev CspFrame if required /// </summary> /// <param name="env"></param> /// <returns></returns> private CspFrame BuildContentSecurityPolicy(IHostingEnvironment env) { if (_cspFrames == null || !_cspFrames.Any()) { _cspFrames = AssembleContentSecurityPolicies(); } // Assemble the master CSP var masterCsp = _cspFrames.Merge(); if (env.IsDevelopment()) { var localhostSp = "localhost:56993/"; var stripe = "http://checkout.stripe.com/"; // Note that this dev CSP includes the http versions for Stripe var devCspFrame = new CspFrame().Initialise("dev"); devCspFrame.Clauses.AddUpdateClause("default-src", "", "http://localhost:5000/") .AddUpdateClause("connect-src", "", "http://" + localhostSp + " ws://" + localhostSp + " " + stripe) .AddUpdateClause("script-src", "", "http://" + localhostSp + " " + stripe); masterCsp = masterCsp.Merge(devCspFrame); } return masterCsp; } Finally include the following in the configuration method just before app.UseMvc( ... // Set up the overall Security Headers // This will also assemble the _cspFrames object if required if (_securityHeaders == null) { _securityHeaders = app.BuildSecurityHeaders(BuildContentSecurityPolicy(env)); } else { _securityHeaders.Csp = BuildContentSecurityPolicy(env); } app.UseSecurityHeaders(_securityHeaders);
Evaluation helpers for conversion quality, completeness, and markdown readiness in ElBruno.MarkItDotNet pipelines.
Avaliacao (evals) de saidas de LLM e agentes para .NET: datasets, evaluators deterministicos e LLM-as-judge, e runner com relatorio agregado. Sobre Microsoft.Extensions.AI — plugue qualquer IChatClient. A parte de medicao de qualidade que o tracing (Langfuse) nao cobre.
Fail-closed evaluation suite for Microsoft Agent Framework. One fluent builder composes deterministic local checks, LLM-judged quality, and any IAgentEvaluator stage over a single agent run, then ends in a gate that cannot silently pass.
A comprehensive evaluation framework for testing Model Context Protocol (MCP) servers with language models. Provides automated testing capabilities, multi-LLM support, and built-in metrics collection.
Evaluate and compile C# at runtime: full statement scripts, live instance binding, a compile-once cache, precompilation, and a security sandbox enforced on the compiled script. Ships the compiler, cache, reflection, and security assemblies merged into one.
With this library you can evaluate math expressions fast and easily. Expression will be compiled into native code, also you can dynamicly change variables.
Roslyn-based C# expression parser and evaluator for .NET. Compiles runtime string expressions to strongly typed Func delegates or LINQ expression trees without creating a new assembly.
This assembly is a catch all utility assembly. It exists because the different utilities within are not big enough to have its own assembly.