Microsoft.VisualBasic.Runtime 10.5.9762.11310.

The sciBASIC# framework library core runtime.

General application services: application and clock helpers, assertion and utility types, the temporary file system and workspace abstractions, and the developer tool extensions.

Runtime debugging support: assertions, debugger levels and arguments, heap size inspection, Visual Studio previews and the exception diagnostics extensions.

Exception diagnostics: exception data and extensions, method and stack frames, trace buffers, and the VisualBasic application exception types.

The logging subsystem: the error log model together with log entries and the log file reader and writer.

The VisualBasic source code file related extension api module.

.NET Core application build models: runtime configuration, MSBuild targets and the dependency (deps.json) descriptors of an application.

The compiled assembly XML documentation model: projects, project spaces, namespaces, types and members together with the doc comment model.

Serialization helpers of the assembly XML documentation model, including the scanning of NamespaceDoc annotations from the documentation object graph.

Dynamic native interop: dynamic library loaders for Windows and Unix, native handle and safe handle types, pointer marshalling extensions and platform utilities.

Localization helpers: the language attribute, the language helper and the string resource lookup used to translate application messages.

Plugin infrastructure: the plugin loader and plugin attribute together with the formatted double converter and format string types.

An interactive terminal toolkit: the shell and console abstractions, line editing with history and completion, markdown and ANSI rendering, console table builders, busy indicators and secure password input.

The interactive line editor: the line reader, input handler, completion states, history and the getline entry point.

Console progress bar controls: the busy indicator, animated and sway bar styles, and the abstract progress bar model.

An element based console progress bar: a composable layout with bodies, descriptions, text, margins, marquee and event handling.

Extension helpers for the console progress bar, covering elements, strings and time span formatting.

A tqdm style console progress bar.

The standard input/output abstraction (IConsole, Shell and STDIO) used by the terminal toolkit.

Console table printing: the console table builder together with the table format and text alignment models used to render tabular text.

The character map and row position flags used to draw console tables, covering borders, headers, meta rows and nullable console colors.

The terminal utility layer: markdown and table rendering, console formatting, ANSI color and escape codes, text spans and unicode width handling, together with the Unix man page models.

Zip archive support: the zip library, zip stream, the unzip helper and the compressed stream reader.

The command line framework: option and argument parsing, the CLI program model, the interpreters and POSIX style conventions.

The CLI interop service: hosts and invokes command line programs across process boundaries.

The interop service pipeline protocol used to stream data between CLI processes.

The shared object relational mapper used by the CLI interop service, including the language specific serializers.

The manual page viewer interpreter used by the CLI framework to render help in a paged view.

The argument and option parsers of the command line framework.

Reflection based CLI binding: the attributes and entry point discovery that map .NET types and members to command line programs.

The CLI entry point abstractions discovered through reflection.

The core component model: shared component and data types, file and XML assembly models, value pairs, bit maps and general collection helpers.

The algorithm namespace root: shared algorithm abstractions used by the binary tree and dynamic programming sub-namespaces.

Combinatorial algorithm primitives: combinations, permutations and related enumeration helpers.

Binary tree algorithms: AVL trees and other balanced binary tree implementations.

Dynamic programming algorithms.

The Levenshtein edit distance dynamic programming algorithm.

Collection and data structure helpers: generic collection extensions, priority queues and concurrent collection utilities.

The double ended queue (deque) data structure.

Generic collection abstractions shared by the collection namespaces.

The data source model: property and repository abstractions that bind .NET entity objects to data sources.

The repository pattern implementation built on the component data source model.

Schema mapping between .NET types and data source columns.

Type casting helpers that map data source values onto CLR types.

General data structures: sets and the related container types.

Binary tree data structures.

Tree data structure base types.

Range types: selectors and structured ranges over numeric and sequence data.

The range model types that describe numeric and sequence ranges.

Units of measurement used by the range model.

Application settings models: the settings data models and configuration containers.

INI style configuration file reading and writing.

Tagged data values: tag/data value pairs and their containers.

Trigger definitions used by the component data structures.

The sciBASIC.NET data handling module

Generic repository abstractions over tabular and file backed data sources.

The Trinity text mining integration: TextRank keyword extraction and PageRank based sentence scoring helpers.

Natural language processing helpers for the Trinity text mining integration.

Dynamic delegate creation through reflection emit.

Marshal helpers for emitting unmanaged interop code.

Parameter reflection helpers used by the reflection emit extensions.

Common file and stream I/O extensions used across the framework.

File path helpers: path parsing, normalization, composition and comparison.

Symbolic link creation and resolution helpers.

The drawing and imaging root: bitmap image models, color schemes and palettes, and the shared drawing graphics utilities.

Bitmap image types and pixel processing helpers.

Bitmap image file stream serialization.

The GDI+ graphics driver implementation of the imaging engine.

The layout model types used by the GDI+ drawing driver.

Euclidean space Euclidean space is the fundamental space of geometry, intended to represent physical space. Originally, in Euclid's Elements, it was the three-dimensional space of Euclidean geometry, but in modern mathematics there are Euclidean spaces of any positive integer dimension n, which are called Euclidean n-spaces when one wants to specify their dimension. For n equal to one or two, they are commonly called respectively Euclidean lines and Euclidean planes. The qualifier "Euclidean" is used to distinguish Euclidean spaces from other spaces that were later considered in physics and modern mathematics. Ancient Greek geometers introduced Euclidean space For modeling the physical space. Their work was collected by the ancient Greek mathematician Euclid In his Elements, With the great innovation Of proving all properties Of the space As theorems, by starting from a few fundamental properties, called postulates, which either were considered As evident (For example, there Is exactly one straight line passing through two points), Or seemed impossible To prove (parallel postulate). After the introduction at the End Of 19th century Of non-Euclidean geometries, the old postulates were re-formalized To define Euclidean spaces through axiomatic theory. Another definition Of Euclidean spaces by means Of vector spaces And linear algebra has been shown To be equivalent To the axiomatic definition. It Is this definition that Is more commonly used In modern mathematics, And detailed In this article. In all definitions, Euclidean spaces consist Of points, which are defined only by the properties that they must have For forming a Euclidean space. There Is essentially only one Euclidean space of each dimension; that Is, all Euclidean spaces of a given dimension are isomorphic. Therefore it Is usually possible to work with a specific Euclidean space, denoted E ^ n, which can be represented using Cartesian coordinates as the real n-space R ^ n equipped with the standard dot product.

The VisualBasic.NET language addons

The C language extension of the language service: C source code models and helpers.

Default value handling for the language value model.

Helper for translate Java source file to VB.NET source file.

Helper types of the LINQ API language surface.

The Perl language extension of the language service.

Helper for translate Python source file to VB.NET source file.

Unix shell (bash) language support: the shell script language service and its helper types.

File system abstractions used by the Unix shell language support.

The language value model shared by the supported scripting languages.

Language level vectorization (SIMD) source rewriting for the LINQ API.

LINQ style sequence extensions: enumerators, iterators, joins, numeric sequences and the vector assertion helpers.

The math core: numeric types, vector operations and the shared mathematical utilities.

Correlation analysis: Pearson, Spearman and related correlation measures.

Information theory measures: entropy, mutual information and related metrics.

Parallel helper routines for math computations.

SIMD hardware accelerated math: arithmetic kernels, the SIMD engine and parallel vector operations.

Automatic vectorization of scalar math expressions into SIMD kernels.

Statistical functions: descriptive statistics and the statistics math extensions.

LINQ style statistical aggregate operators.

The application framework (My) root namespace: application information, resources and the framework plugin container.

The sciBASIC.NET framework config module

JavaScript interop for .NET: the JavaScript object model, marshalling and serialization helpers.

ECMAScript 6 (ES6) language features exposed to the .NET JavaScript interop layer.

Unix platform helpers exposed through the application framework.

Core networking types: the IP and socket abstractions shared by the network protocol implementations.

Abstract network types: the network stream and endpoint abstractions.

The FTP protocol client.

The HTTP protocol implementation: requests and responses, streaming and the web service helper types.

JSON-RPC 2.0 client support over HTTP.

MIME content type handling for network protocol messages.

The TCP socket transport and IPv4 endpoint handling.

The web client (wget style) download helpers.

The parallel computing framework: data pipes and stream buffers, memory mapped file channels, process locking and workflow helpers.

Parallel LINQ query scheduling over the thread pool.

The memory mapped file (MMF) protocol: the channel and message reader/writer used for inter process communication.

The memory mapped stream implementation backing the MMF protocol channel.

Parallel tasks: asynchronous handles, background and callback tasks, the task queue and task partitions.

Thread pool management: the thread pool, thread queue and the update thread used for concurrent execution.

Printing support: printer selection and print document abstractions.

The script engine root: host integration, script metadata and the shared scripting services used by the supported script languages.

Script expressions: the expression tree model and its evaluation.

Script metadata: the declaration, function, module and script metadata extracted from script sources.

The scripting runtime: type conversion, runtime objects and the execution services.

The symbol builder that turns parsed scripts into executable symbol trees.

The Visual Basic script dialect support of the script symbol builder.

The script tokenizer with the script token model.

Secure string handling: encryption and protection helpers for sensitive text.

Serialization infrastructure: configuration mappings and the shared serializer helpers.

Bencode (BitTorrent encoding) reading and writing together with the element model.

Binary dumping of object graphs, including the stream based dumper.

JSON serialization: the JSON serializer, the object model and the schema provider.

The JSON formatter and its entry point for pretty printing JSON text.

The single character strategy implementations used by the JSON formatter state machine.

Text processing: string utilities, text stream I/O, character encoding helpers and string splitting.

The Levenshtein string similarity implementation.

The text parser framework: token streams, lexical scanners and grammar helpers used to build text parsers.

The HTML parser built on the text parser framework.

text patterns and validations

Validators for the text pattern definitions.

Text search and indexing: text segments and the inverted text index.

String similarity measures and the equality comparer abstractions.

XML document construction and parsing: the XML document tree, element extensions, declarations and the XML string collection types.

LINQ style XML querying: the XML stream reader, node iterators and deserialization handlers.

The XML value models: string, numeric, list, sequence, vector, coordinate and value tuple models.

Open XML package parts: the content types and relationship (rels) models.

Value type helpers: extensions for numeric and other value types.