Marcus Cuda
17 years ago
committed by
Christoph Ruegg
Christoph Ruegg
6 changed files with 1238 additions and 23 deletions
@ -0,0 +1,16 @@ |
|||
namespace MathNet.Numerics.UnitTests |
|||
{ |
|||
using MbUnit.Framework; |
|||
|
|||
[TestFixture] |
|||
public class ComplexTest |
|||
{ |
|||
[Test, MultipleAsserts] |
|||
public void CanCreateAComplexNumberUsingTheConstructor() |
|||
{ |
|||
var complex = new Complex(1.1, -2.2); |
|||
AssertEx.That(() => complex.Real == 1.1, "Real Part"); |
|||
AssertEx.That(() => complex.Imaginary == -2.2, "Imaginary Part"); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,439 @@ |
|||
// <copyright file="Complex.cs" company="Math.NET">
|
|||
// Math.NET Numerics, part of the Math.NET Project
|
|||
// http://mathnet.opensourcedotnet.info
|
|||
//
|
|||
// Copyright (c) 2009 Math.NET
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person
|
|||
// obtaining a copy of this software and associated documentation
|
|||
// files (the "Software"), to deal in the Software without
|
|||
// restriction, including without limitation the rights to use,
|
|||
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|||
// copies of the Software, and to permit persons to whom the
|
|||
// Software is furnished to do so, subject to the following
|
|||
// conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be
|
|||
// included in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|||
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|||
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|||
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|||
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|||
// OTHER DEALINGS IN THE SOFTWARE.
|
|||
// </copyright>
|
|||
|
|||
namespace MathNet.Numerics |
|||
{ |
|||
using System; |
|||
using System.Runtime.InteropServices; |
|||
using System.Text; |
|||
using System.Text.RegularExpressions; |
|||
using Properties; |
|||
|
|||
/// <summary>
|
|||
/// Complex numbers class.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// <para>The class <c>Complex</c> provides all elementary operations
|
|||
/// on complex numbers. All the operators <c>+</c>, <c>-</c>,
|
|||
/// <c>*</c>, <c>/</c>, <c>==</c>, <c>!=</c> are defined in the
|
|||
/// canonical way. Additional complex trigonometric functions such
|
|||
/// as <see cref="Complex.Cosine"/>, ...
|
|||
/// are also provided. Note that the <c>Complex</c> structures
|
|||
/// has two special constant values <see cref="Complex.NaN"/> and
|
|||
/// <see cref="Complex.Infinity"/>.</para>
|
|||
/// <para>In order to avoid possible ambiguities resulting from a
|
|||
/// <c>Complex(double, double)</c> constructor, the static methods
|
|||
/// <see cref="Complex.FromRealImaginary"/> and <see cref="Complex.FromModulusArgument"/>
|
|||
/// are provided instead.</para>
|
|||
/// <para><code>
|
|||
/// Complex x = Complex.FromRealImaginary(1d, 2d);
|
|||
/// Complex y = Complex.FromModulusArgument(1d, Math.Pi);
|
|||
/// Complex z = (x + y) / (x - y);
|
|||
/// </code></para>
|
|||
/// <para>Since there is no canonical order among the complex numbers,
|
|||
/// <c>Complex</c> does not implement <c>IComparable</c> but several
|
|||
/// lexicographic <c>IComparer</c> implementations are provided, see
|
|||
/// <see cref="Complex.RealImaginaryComparer"/>,
|
|||
/// <see cref="Complex.ModulusArgumentComparer"/> and
|
|||
/// <see cref="Complex.ArgumentModulusComparer"/>.</para>
|
|||
/// <para>For mathematical details about complex numbers, please
|
|||
/// have a look at the <a href="http://en.wikipedia.org/wiki/Complex_number">
|
|||
/// Wikipedia</a></para>
|
|||
/// </remarks>
|
|||
[Serializable] |
|||
[StructLayout(LayoutKind.Sequential)] |
|||
public struct Complex : IFormattable, IEquatable<Complex> |
|||
{ |
|||
#region fields
|
|||
|
|||
/// <summary>
|
|||
/// Regular expressionused to parse strings into complex numbers.
|
|||
/// </summary>
|
|||
private static readonly Regex parseExpression = new Regex(@"^((?<r>(([-+]?(\d+\.?\d*|\d*\.?\d+)([Ee][-+]?[0-9]+)?)|(NaN)|([-+]?Infinity)))|(?<i>(([-+]?((\d+\.?\d*|\d*\.?\d+)([Ee][-+]?[0-9]+)?)|(NaN)|([-+]?Infinity))?[i]))|(?<r>(([-+]?(\d+\.?\d*|\d*\.?\d+)([Ee][-+]?[0-9]+)?)|(NaN)|([-+]?Infinity)))(?<i>(([-+]((\d+\.?\d*|\d*\.?\d+)([Ee][-+]?[0-9]+)?)|[-+](NaN)|([-+]Infinity))?[i])))$", RegexOptions.Singleline | RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace); |
|||
|
|||
/// <summary>
|
|||
/// Represents imaginary unit number.
|
|||
/// </summary>
|
|||
private static readonly Complex i = new Complex(0, 1); |
|||
|
|||
/// <summary>
|
|||
/// Represents a infite complex number
|
|||
/// </summary>
|
|||
private static readonly Complex infinity = new Complex(double.PositiveInfinity, double.PositiveInfinity); |
|||
|
|||
/// <summary>
|
|||
/// Reprensents not-a-number.
|
|||
/// </summary>
|
|||
private static readonly Complex nan = new Complex(Double.NaN, Double.NaN); |
|||
|
|||
/// <summary>
|
|||
/// Representing the one value.
|
|||
/// </summary>
|
|||
private static readonly Complex one = new Complex(1.0, 0.0); |
|||
|
|||
/// <summary>
|
|||
/// Representing the zero value.
|
|||
/// </summary>
|
|||
private static readonly Complex zero = new Complex(0.0, 0.0); |
|||
|
|||
/// <summary>
|
|||
/// The real component of the complex number.
|
|||
/// </summary>
|
|||
private readonly double real; |
|||
|
|||
/// <summary>
|
|||
/// The imaginary component of the complex number.
|
|||
/// </summary>
|
|||
private readonly double imag; |
|||
|
|||
#endregion fields
|
|||
|
|||
#region Constructor
|
|||
|
|||
/// <summary>
|
|||
/// Initializes a new instance of the Complex struct with the given real
|
|||
/// and imaginary parts.
|
|||
/// </summary>
|
|||
/// <param name="real">The value for the real component.</param>
|
|||
/// <param name="imaginary">The value for the imaginary component.</param>
|
|||
public Complex(double real, double imaginary) |
|||
{ |
|||
this.real = real; |
|||
this.imag = imaginary; |
|||
} |
|||
|
|||
#endregion
|
|||
|
|||
#region Properties
|
|||
|
|||
/// <summary>
|
|||
/// Gets a value representing the infinity value. This field is constant.
|
|||
/// </summary>
|
|||
/// <value>The infinity.</value>
|
|||
/// <remarks>
|
|||
/// The semantic associated to this value is a <c>Complex</c> of
|
|||
/// infinite real and imaginary part. If you need more formal complex
|
|||
/// number handling (according to the Riemann Sphere and the extended
|
|||
/// complex plane C*, or using directed infinity) please check out the
|
|||
/// alternative MathNet.PreciseNumerics and MathNet.Symbolics packages
|
|||
/// instead.
|
|||
/// </remarks>
|
|||
/// <value>A value representing the infinity value.</value>
|
|||
public static Complex Infinity |
|||
{ |
|||
get { return infinity; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value representing not-a-number. This field is constant.
|
|||
/// </summary>
|
|||
/// <value>A value representing not-a-number.</value>
|
|||
public static Complex NaN |
|||
{ |
|||
get { return nan; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value representing the imaginary unit number. This field is constant.
|
|||
/// </summary>
|
|||
/// <value>A value representing the imaginary unit number.</value>
|
|||
public static Complex I |
|||
{ |
|||
get { return i; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value representing the zero value. This field is constant.
|
|||
/// </summary>
|
|||
/// <value>A value representing the zero value.</value>
|
|||
public static Complex Zero |
|||
{ |
|||
get { return new Complex(0.0, 0.0); } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value representing the <c>1</c> value. This field is constant.
|
|||
/// </summary>
|
|||
/// <value>A value representing the <c>1</c> value.</value>
|
|||
public static Complex One |
|||
{ |
|||
get { return one; } |
|||
} |
|||
|
|||
#endregion Properties
|
|||
|
|||
/// <summary>
|
|||
/// Gets the real component of the complex number.
|
|||
/// </summary>
|
|||
/// <value>The real component of the complex number.</value>
|
|||
public double Real |
|||
{ |
|||
get { return this.real; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets the real imaginary component of the complex number.
|
|||
/// </summary>
|
|||
/// <value>The real imaginary component of the complex number.</value>
|
|||
public double Imaginary |
|||
{ |
|||
get { return this.imag; } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether whether the <c>Complex</c> is zero.
|
|||
/// </summary>
|
|||
/// <value><c>true</c> if this instance is zero; otherwise, <c>false</c>.</value>
|
|||
public bool IsZero |
|||
{ |
|||
get { throw new NotImplementedException(); } // return Number.AlmostZero(real) && Number.AlmostZero(imag); }
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether the <c>Complex</c> is one.
|
|||
/// </summary>
|
|||
/// <value><c>true</c> if this instance is one; otherwise, <c>false</c>.</value>
|
|||
public bool IsOne |
|||
{ |
|||
get { throw new NotImplementedException(); } // return Number.AlmostEqual(real, 1) && Number.AlmostZero(imag); }
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether the <c>Complex</c> is the imaginary unit.
|
|||
/// </summary>
|
|||
/// <value><c>true</c> if this instance is I; otherwise, <c>false</c>.</value>
|
|||
public bool IsI |
|||
{ |
|||
get { throw new NotImplementedException(); } // return Number.AlmostZero(real) && Number.AlmostEqual(imag, 1); }
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether the provided <c>Complex</c> evaluates to a
|
|||
/// value that is not a number.
|
|||
/// </summary>
|
|||
/// <value><c>true</c> if this instance is NaN; otherwise, <c>false</c>.</value>
|
|||
public bool IsNaN |
|||
{ |
|||
get { throw new NotImplementedException(); } // return double.IsNaN(real) || double.IsNaN(imag); }
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether the provided <c>Complex</c> evaluates to an
|
|||
/// infinite value.
|
|||
/// </summary>
|
|||
/// <value>
|
|||
/// <c>true</c> if this instance is infinie; otherwise, <c>false</c>.
|
|||
/// </value>
|
|||
/// <remarks>
|
|||
/// True if it either evaluates to a complex infinity
|
|||
/// or to a directed infinity.
|
|||
/// </remarks>
|
|||
public bool IsInfinity |
|||
{ |
|||
get { return double.IsInfinity(this.real) || double.IsInfinity(this.imag); } |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether the provided <c>Complex</c> is real.
|
|||
/// </summary>
|
|||
/// <value><c>true</c> if this instance is a real number; otherwise, <c>false</c>.</value>
|
|||
public bool IsReal |
|||
{ |
|||
get { throw new NotImplementedException(); } // return Number.AlmostZero(imag); }
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whether the provided <c>Complex</c> is real and not negative, that is >= 0.
|
|||
/// </summary>
|
|||
/// <value>
|
|||
/// <c>true</c> if this instance is real nonnegative number; otherwise, <c>false</c>.
|
|||
/// </value>
|
|||
public bool IsRealNonNegative |
|||
{ |
|||
get { throw new NotImplementedException(); } // return Number.AlmostZero(imag) && real >= 0; }
|
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a value indicating whetherthe provided <c>Complex</c> is imaginary.
|
|||
/// </summary>
|
|||
/// <value>
|
|||
/// <c>true</c> if this instance is an imaginary number; otherwise, <c>false</c>.
|
|||
/// </value>
|
|||
public bool IsImaginary |
|||
{ |
|||
get { throw new NotImplementedException(); } // return Number.AlmostZero(real); }
|
|||
} |
|||
|
|||
#region Static Initializers
|
|||
|
|||
/// <summary>
|
|||
/// Constructs a <c>Complex</c> from its real
|
|||
/// and imaginary parts.
|
|||
/// </summary>
|
|||
/// <param name="real">The value for the real component.</param>
|
|||
/// <param name="imaginary">The value for the imaginary component.</param>
|
|||
/// <returns>A new <c>Complex</c> with the given values.</returns>
|
|||
public static Complex FromRealImaginary(double real, double imaginary) |
|||
{ |
|||
return new Complex(real, imaginary); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Constructs a <c>Complex</c> from its modulus and
|
|||
/// argument.
|
|||
/// </summary>
|
|||
/// <param name="modulus">Must be non-negative.</param>
|
|||
/// <param name="argument">Real number.</param>
|
|||
/// <returns>A new <c>Complex</c> from the given values.</returns>
|
|||
public static Complex FromModulusArgument(double modulus, double argument) |
|||
{ |
|||
if (modulus < 0.0) |
|||
{ |
|||
throw new ArgumentOutOfRangeException("modulus", modulus, Resources.ArgumentNotNegative); |
|||
} |
|||
|
|||
return new Complex(modulus * Math.Cos(argument), modulus * Math.Sin(argument)); |
|||
} |
|||
|
|||
#endregion
|
|||
|
|||
#region IFormattable Members
|
|||
|
|||
/// <summary>A string representation of this complex number.</summary>
|
|||
/// <returns>The string representation of this complex number.</returns>
|
|||
public override string ToString() |
|||
{ |
|||
return this.ToString(null, null); |
|||
} |
|||
|
|||
/// <summary>A string representation of this complex number.</summary>
|
|||
/// <returns>
|
|||
/// The string representation of this complex number formatted as specified by the
|
|||
/// format string.
|
|||
/// </returns>
|
|||
/// <param name="format">A format specification.</param>
|
|||
public string ToString(string format) |
|||
{ |
|||
return this.ToString(format, null); |
|||
} |
|||
|
|||
/// <summary>A string representation of this complex number.</summary>
|
|||
/// <returns>
|
|||
/// The string representation of this complex number formatted as specified by the
|
|||
/// format provider.
|
|||
/// </returns>
|
|||
/// <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
|
|||
public string ToString(IFormatProvider formatProvider) |
|||
{ |
|||
return this.ToString(null, formatProvider); |
|||
} |
|||
|
|||
/// <summary>A string representation of this complex number.</summary>
|
|||
/// <returns>
|
|||
/// The string representation of this complex number formatted as specified by the
|
|||
/// format string and format provider.
|
|||
/// </returns>
|
|||
/// <exception cref="FormatException">if the n, is not a number.</exception>
|
|||
/// <exception cref="ArgumentNullException">if s, is <see langword="null" />.</exception>
|
|||
/// <param name="format">A format specification.</param>
|
|||
/// <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
|
|||
public string ToString(string format, IFormatProvider formatProvider) |
|||
{ |
|||
if (this.IsNaN) |
|||
{ |
|||
return "NaN"; |
|||
} |
|||
|
|||
if (this.IsInfinity) |
|||
{ |
|||
return "Infinity"; |
|||
} |
|||
|
|||
var ret = new StringBuilder(); |
|||
|
|||
ret.Append(this.real.ToString(format, formatProvider)); |
|||
if (this.imag < 0) |
|||
{ |
|||
ret.Append(" "); |
|||
} |
|||
else |
|||
{ |
|||
ret.Append(" + "); |
|||
} |
|||
|
|||
ret.Append(this.imag.ToString(format, formatProvider)).Append("i"); |
|||
|
|||
return ret.ToString(); |
|||
} |
|||
|
|||
#endregion
|
|||
|
|||
#region IEquatable<Complex> Members
|
|||
|
|||
/// <summary>
|
|||
/// Checks if two complex numbers are equal. Two complex numbers are equal if their
|
|||
/// corresponding real and imaginary components are equal.
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// Returns true if the two objects are the same object, or if their corresponding
|
|||
/// real and imaginary components are equal, false otherwise.
|
|||
/// </returns>
|
|||
/// <param name="other">The complex number to compare to with.</param>
|
|||
public bool Equals(Complex other) |
|||
{ |
|||
return this.Real == other.Real && this.Imaginary == other.Imaginary; |
|||
} |
|||
|
|||
/// <summary>The hash code for the complex number.</summary>
|
|||
/// <returns>The hash code of the complex number.</returns>
|
|||
/// <remarks>
|
|||
/// The hash code is calculated as
|
|||
/// System.Math.Exp(ComplexMath.Absolute(complexNumber)).
|
|||
/// </remarks>
|
|||
public override int GetHashCode() |
|||
{ |
|||
return this.real.GetHashCode() ^ (-this.imag.GetHashCode()); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Checks if two complex numbers are equal. Two complex numbers are equal if their
|
|||
/// corresponding real and imaginary components are equal.
|
|||
/// </summary>
|
|||
/// <returns>
|
|||
/// Returns true if the two objects are the same object, or if their corresponding
|
|||
/// real and imaginary components are equal, false otherwise.
|
|||
/// </returns>
|
|||
/// <param name="obj">The complex number to compare to with.</param>
|
|||
public override bool Equals(object obj) |
|||
{ |
|||
return (obj is Complex) && this.Equals((Complex) obj); |
|||
} |
|||
|
|||
#endregion
|
|||
} |
|||
} |
|||
@ -0,0 +1,512 @@ |
|||
//------------------------------------------------------------------------------
|
|||
// <auto-generated>
|
|||
// This code was generated by a tool.
|
|||
// Runtime Version:4.0.20506.1
|
|||
//
|
|||
// Changes to this file may cause incorrect behavior and will be lost if
|
|||
// the code is regenerated.
|
|||
// </auto-generated>
|
|||
//------------------------------------------------------------------------------
|
|||
|
|||
namespace MathNet.Numerics.Properties |
|||
{ |
|||
using System; |
|||
|
|||
|
|||
/// <summary>
|
|||
/// A strongly-typed resource class, for looking up localized strings, etc.
|
|||
/// </summary>
|
|||
// This class was auto-generated by the StronglyTypedResourceBuilder
|
|||
// class via a tool like ResGen or Visual Studio.
|
|||
// To add or remove a member, edit your .ResX file then rerun ResGen
|
|||
// with the /str option, or rebuild your VS project.
|
|||
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] |
|||
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] |
|||
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] |
|||
internal class Resources |
|||
{ |
|||
|
|||
private static global::System.Resources.ResourceManager resourceMan; |
|||
|
|||
private static global::System.Globalization.CultureInfo resourceCulture; |
|||
|
|||
[global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] |
|||
internal Resources() |
|||
{ |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Returns the cached ResourceManager instance used by this class.
|
|||
/// </summary>
|
|||
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] |
|||
internal static global::System.Resources.ResourceManager ResourceManager |
|||
{ |
|||
get |
|||
{ |
|||
if (object.ReferenceEquals(resourceMan, null)) |
|||
{ |
|||
global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("MathNet.Numerics.Properties.Resources", typeof(Resources).Assembly); |
|||
resourceMan = temp; |
|||
} |
|||
return resourceMan; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Overrides the current thread's CurrentUICulture property for all
|
|||
/// resource lookups using this strongly typed resource class.
|
|||
/// </summary>
|
|||
[global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] |
|||
internal static global::System.Globalization.CultureInfo Culture |
|||
{ |
|||
get |
|||
{ |
|||
return resourceCulture; |
|||
} |
|||
set |
|||
{ |
|||
resourceCulture = value; |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to The histogram does not contains the value {0}..
|
|||
/// </summary>
|
|||
internal static string ArgumentHistogramContainsNot |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentHistogramContainsNot", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Value is expected to be between {0} and {1} (including {0} and {1})..
|
|||
/// </summary>
|
|||
internal static string ArgumentInIntervalXYInclusive |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentInIntervalXYInclusive", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to The matrix indices must not be out of range of the given matrix..
|
|||
/// </summary>
|
|||
internal static string ArgumentMatrixIndexOutOfRange |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentMatrixIndexOutOfRange", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Matrix must not be rank deficient..
|
|||
/// </summary>
|
|||
internal static string ArgumentMatrixNotRankDeficient |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentMatrixNotRankDeficient", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Matrix must not be singular..
|
|||
/// </summary>
|
|||
internal static string ArgumentMatrixNotSingular |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentMatrixNotSingular", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Matrix column dimensions must agree..
|
|||
/// </summary>
|
|||
internal static string ArgumentMatrixSameColumnDimension |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentMatrixSameColumnDimension", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Matrix dimensions must agree..
|
|||
/// </summary>
|
|||
internal static string ArgumentMatrixSameDimensions |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentMatrixSameDimensions", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Matrix row dimensions must agree..
|
|||
/// </summary>
|
|||
internal static string ArgumentMatrixSameRowDimension |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentMatrixSameRowDimension", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Matrix must have exactly one column..
|
|||
/// </summary>
|
|||
internal static string ArgumentMatrixSingleColumn |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentMatrixSingleColumn", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Matrix must have exactly one column and row, thus have only one cell..
|
|||
/// </summary>
|
|||
internal static string ArgumentMatrixSingleColumnRow |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentMatrixSingleColumnRow", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Matrix must have exactly one row..
|
|||
/// </summary>
|
|||
internal static string ArgumentMatrixSingleRow |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentMatrixSingleRow", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Matrix must be square..
|
|||
/// </summary>
|
|||
internal static string ArgumentMatrixSquare |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentMatrixSquare", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Matrix must be symmetric..
|
|||
/// </summary>
|
|||
internal static string ArgumentMatrixSymmetric |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentMatrixSymmetric", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Matrix must be symmetric positive definite..
|
|||
/// </summary>
|
|||
internal static string ArgumentMatrixSymmetricPositiveDefinite |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentMatrixSymmetricPositiveDefinite", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Value must neither be infinite nor NaN..
|
|||
/// </summary>
|
|||
internal static string ArgumentNotInfinityNaN |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentNotInfinityNaN", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Value must not be negative (zero is ok)..
|
|||
/// </summary>
|
|||
internal static string ArgumentNotNegative |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentNotNegative", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to {0} is a null reference (Nothing in Visual Basic)..
|
|||
/// </summary>
|
|||
internal static string ArgumentNull |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentNull", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to {0} must be greater than {1}..
|
|||
/// </summary>
|
|||
internal static string ArgumentOutOfRangeGreater |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentOutOfRangeGreater", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to {0} must be greater than or equal to {1}..
|
|||
/// </summary>
|
|||
internal static string ArgumentOutOfRangeGreaterEqual |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentOutOfRangeGreaterEqual", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to The chosen parameter set is invalid (probably some value is out of range)..
|
|||
/// </summary>
|
|||
internal static string ArgumentParameterSetInvalid |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentParameterSetInvalid", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to The given expression does not represent a complex number..
|
|||
/// </summary>
|
|||
internal static string ArgumentParseComplexNumber |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentParseComplexNumber", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Value must be positive (and not zero)..
|
|||
/// </summary>
|
|||
internal static string ArgumentPositive |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentPositive", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Size must be a Power of Two..
|
|||
/// </summary>
|
|||
internal static string ArgumentPowerOfTwo |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentPowerOfTwo", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Size must be a Power of Two in every dimension..
|
|||
/// </summary>
|
|||
internal static string ArgumentPowerOfTwoEveryDimension |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentPowerOfTwoEveryDimension", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to The range between {0} and {1} must be less than or equal to {2}..
|
|||
/// </summary>
|
|||
internal static string ArgumentRangeLessEqual |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentRangeLessEqual", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Array must have exactly one dimension (and not be null)..
|
|||
/// </summary>
|
|||
internal static string ArgumentSingleDimensionArray |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentSingleDimensionArray", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Value is too large..
|
|||
/// </summary>
|
|||
internal static string ArgumentTooLarge |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentTooLarge", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Value is too large for the current iteration limit..
|
|||
/// </summary>
|
|||
internal static string ArgumentTooLargeForIterationLimit |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentTooLargeForIterationLimit", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Type mismatch..
|
|||
/// </summary>
|
|||
internal static string ArgumentTypeMismatch |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentTypeMismatch", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Array length must be a multiple of {0}..
|
|||
/// </summary>
|
|||
internal static string ArgumentVectorLengthsMultipleOf |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentVectorLengthsMultipleOf", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to All vectors must have the same dimensionality..
|
|||
/// </summary>
|
|||
internal static string ArgumentVectorsSameLengths |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentVectorsSameLengths", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to The vector must have 3 dimensions..
|
|||
/// </summary>
|
|||
internal static string ArgumentVectorThreeDimensional |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("ArgumentVectorThreeDimensional", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to This feature is not implemented yet (but is planned)..
|
|||
/// </summary>
|
|||
internal static string FeaturePlannedButNotImplementedYet |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("FeaturePlannedButNotImplementedYet", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Invalid Left Boundary Condition..
|
|||
/// </summary>
|
|||
internal static string InvalidLeftBoundaryCondition |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("InvalidLeftBoundaryCondition", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to The operation could not be performed because the accumulator is empty..
|
|||
/// </summary>
|
|||
internal static string InvalidOperationAccumulatorEmpty |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("InvalidOperationAccumulatorEmpty", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to The operation could not be performed because the histogram is empty..
|
|||
/// </summary>
|
|||
internal static string InvalidOperationHistogramEmpty |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("InvalidOperationHistogramEmpty", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Not enough points in the distribution..
|
|||
/// </summary>
|
|||
internal static string InvalidOperationHistogramNotEnoughPoints |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("InvalidOperationHistogramNotEnoughPoints", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to No Samples Provided. Preparation Required..
|
|||
/// </summary>
|
|||
internal static string InvalidOperationNoSamplesProvided |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("InvalidOperationNoSamplesProvided", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to Invalid Right Boundary Condition..
|
|||
/// </summary>
|
|||
internal static string InvalidRightBoundaryCondition |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("InvalidRightBoundaryCondition", resourceCulture); |
|||
} |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Looks up a localized string similar to This special case is not supported yet (but is planned)..
|
|||
/// </summary>
|
|||
internal static string SpecialCasePlannedButNotImplementedYet |
|||
{ |
|||
get |
|||
{ |
|||
return ResourceManager.GetString("SpecialCasePlannedButNotImplementedYet", resourceCulture); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,240 @@ |
|||
<?xml version="1.0" encoding="utf-8"?> |
|||
<root> |
|||
<!-- |
|||
Microsoft ResX Schema |
|||
|
|||
Version 2.0 |
|||
|
|||
The primary goals of this format is to allow a simple XML format |
|||
that is mostly human readable. The generation and parsing of the |
|||
various data types are done through the TypeConverter classes |
|||
associated with the data types. |
|||
|
|||
Example: |
|||
|
|||
... ado.net/XML headers & schema ... |
|||
<resheader name="resmimetype">text/microsoft-resx</resheader> |
|||
<resheader name="version">2.0</resheader> |
|||
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader> |
|||
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader> |
|||
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data> |
|||
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data> |
|||
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64"> |
|||
<value>[base64 mime encoded serialized .NET Framework object]</value> |
|||
</data> |
|||
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64"> |
|||
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value> |
|||
<comment>This is a comment</comment> |
|||
</data> |
|||
|
|||
There are any number of "resheader" rows that contain simple |
|||
name/value pairs. |
|||
|
|||
Each data row contains a name, and value. The row also contains a |
|||
type or mimetype. Type corresponds to a .NET class that support |
|||
text/value conversion through the TypeConverter architecture. |
|||
Classes that don't support this are serialized and stored with the |
|||
mimetype set. |
|||
|
|||
The mimetype is used for serialized objects, and tells the |
|||
ResXResourceReader how to depersist the object. This is currently not |
|||
extensible. For a given mimetype the value must be set accordingly: |
|||
|
|||
Note - application/x-microsoft.net.object.binary.base64 is the format |
|||
that the ResXResourceWriter will generate, however the reader can |
|||
read any of the formats listed below. |
|||
|
|||
mimetype: application/x-microsoft.net.object.binary.base64 |
|||
value : The object must be serialized with |
|||
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter |
|||
: and then encoded with base64 encoding. |
|||
|
|||
mimetype: application/x-microsoft.net.object.soap.base64 |
|||
value : The object must be serialized with |
|||
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter |
|||
: and then encoded with base64 encoding. |
|||
|
|||
mimetype: application/x-microsoft.net.object.bytearray.base64 |
|||
value : The object must be serialized into a byte array |
|||
: using a System.ComponentModel.TypeConverter |
|||
: and then encoded with base64 encoding. |
|||
--> |
|||
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata"> |
|||
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" /> |
|||
<xsd:element name="root" msdata:IsDataSet="true"> |
|||
<xsd:complexType> |
|||
<xsd:choice maxOccurs="unbounded"> |
|||
<xsd:element name="metadata"> |
|||
<xsd:complexType> |
|||
<xsd:sequence> |
|||
<xsd:element name="value" type="xsd:string" minOccurs="0" /> |
|||
</xsd:sequence> |
|||
<xsd:attribute name="name" use="required" type="xsd:string" /> |
|||
<xsd:attribute name="type" type="xsd:string" /> |
|||
<xsd:attribute name="mimetype" type="xsd:string" /> |
|||
<xsd:attribute ref="xml:space" /> |
|||
</xsd:complexType> |
|||
</xsd:element> |
|||
<xsd:element name="assembly"> |
|||
<xsd:complexType> |
|||
<xsd:attribute name="alias" type="xsd:string" /> |
|||
<xsd:attribute name="name" type="xsd:string" /> |
|||
</xsd:complexType> |
|||
</xsd:element> |
|||
<xsd:element name="data"> |
|||
<xsd:complexType> |
|||
<xsd:sequence> |
|||
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> |
|||
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" /> |
|||
</xsd:sequence> |
|||
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" /> |
|||
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" /> |
|||
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" /> |
|||
<xsd:attribute ref="xml:space" /> |
|||
</xsd:complexType> |
|||
</xsd:element> |
|||
<xsd:element name="resheader"> |
|||
<xsd:complexType> |
|||
<xsd:sequence> |
|||
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" /> |
|||
</xsd:sequence> |
|||
<xsd:attribute name="name" type="xsd:string" use="required" /> |
|||
</xsd:complexType> |
|||
</xsd:element> |
|||
</xsd:choice> |
|||
</xsd:complexType> |
|||
</xsd:element> |
|||
</xsd:schema> |
|||
<resheader name="resmimetype"> |
|||
<value>text/microsoft-resx</value> |
|||
</resheader> |
|||
<resheader name="version"> |
|||
<value>2.0</value> |
|||
</resheader> |
|||
<resheader name="reader"> |
|||
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> |
|||
</resheader> |
|||
<resheader name="writer"> |
|||
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value> |
|||
</resheader> |
|||
<data name="ArgumentHistogramContainsNot" xml:space="preserve"> |
|||
<value>The histogram does not contains the value {0}.</value> |
|||
</data> |
|||
<data name="ArgumentInIntervalXYInclusive" xml:space="preserve"> |
|||
<value>Value is expected to be between {0} and {1} (including {0} and {1}).</value> |
|||
</data> |
|||
<data name="ArgumentMatrixIndexOutOfRange" xml:space="preserve"> |
|||
<value>The matrix indices must not be out of range of the given matrix.</value> |
|||
</data> |
|||
<data name="ArgumentMatrixNotRankDeficient" xml:space="preserve"> |
|||
<value>Matrix must not be rank deficient.</value> |
|||
</data> |
|||
<data name="ArgumentMatrixNotSingular" xml:space="preserve"> |
|||
<value>Matrix must not be singular.</value> |
|||
</data> |
|||
<data name="ArgumentMatrixSameColumnDimension" xml:space="preserve"> |
|||
<value>Matrix column dimensions must agree.</value> |
|||
</data> |
|||
<data name="ArgumentMatrixSameDimensions" xml:space="preserve"> |
|||
<value>Matrix dimensions must agree.</value> |
|||
</data> |
|||
<data name="ArgumentMatrixSameRowDimension" xml:space="preserve"> |
|||
<value>Matrix row dimensions must agree.</value> |
|||
</data> |
|||
<data name="ArgumentMatrixSingleColumn" xml:space="preserve"> |
|||
<value>Matrix must have exactly one column.</value> |
|||
</data> |
|||
<data name="ArgumentMatrixSingleColumnRow" xml:space="preserve"> |
|||
<value>Matrix must have exactly one column and row, thus have only one cell.</value> |
|||
</data> |
|||
<data name="ArgumentMatrixSingleRow" xml:space="preserve"> |
|||
<value>Matrix must have exactly one row.</value> |
|||
</data> |
|||
<data name="ArgumentMatrixSquare" xml:space="preserve"> |
|||
<value>Matrix must be square.</value> |
|||
</data> |
|||
<data name="ArgumentMatrixSymmetric" xml:space="preserve"> |
|||
<value>Matrix must be symmetric.</value> |
|||
</data> |
|||
<data name="ArgumentMatrixSymmetricPositiveDefinite" xml:space="preserve"> |
|||
<value>Matrix must be symmetric positive definite.</value> |
|||
</data> |
|||
<data name="ArgumentNotInfinityNaN" xml:space="preserve"> |
|||
<value>Value must neither be infinite nor NaN.</value> |
|||
</data> |
|||
<data name="ArgumentNotNegative" xml:space="preserve"> |
|||
<value>Value must not be negative (zero is ok).</value> |
|||
</data> |
|||
<data name="ArgumentNull" xml:space="preserve"> |
|||
<value>{0} is a null reference (Nothing in Visual Basic).</value> |
|||
</data> |
|||
<data name="ArgumentOutOfRangeGreater" xml:space="preserve"> |
|||
<value>{0} must be greater than {1}.</value> |
|||
</data> |
|||
<data name="ArgumentOutOfRangeGreaterEqual" xml:space="preserve"> |
|||
<value>{0} must be greater than or equal to {1}.</value> |
|||
</data> |
|||
<data name="ArgumentParameterSetInvalid" xml:space="preserve"> |
|||
<value>The chosen parameter set is invalid (probably some value is out of range).</value> |
|||
</data> |
|||
<data name="ArgumentParseComplexNumber" xml:space="preserve"> |
|||
<value>The given expression does not represent a complex number.</value> |
|||
</data> |
|||
<data name="ArgumentPositive" xml:space="preserve"> |
|||
<value>Value must be positive (and not zero).</value> |
|||
</data> |
|||
<data name="ArgumentPowerOfTwo" xml:space="preserve"> |
|||
<value>Size must be a Power of Two.</value> |
|||
</data> |
|||
<data name="ArgumentPowerOfTwoEveryDimension" xml:space="preserve"> |
|||
<value>Size must be a Power of Two in every dimension.</value> |
|||
</data> |
|||
<data name="ArgumentRangeLessEqual" xml:space="preserve"> |
|||
<value>The range between {0} and {1} must be less than or equal to {2}.</value> |
|||
</data> |
|||
<data name="ArgumentSingleDimensionArray" xml:space="preserve"> |
|||
<value>Array must have exactly one dimension (and not be null).</value> |
|||
</data> |
|||
<data name="ArgumentTooLarge" xml:space="preserve"> |
|||
<value>Value is too large.</value> |
|||
</data> |
|||
<data name="ArgumentTooLargeForIterationLimit" xml:space="preserve"> |
|||
<value>Value is too large for the current iteration limit.</value> |
|||
</data> |
|||
<data name="ArgumentTypeMismatch" xml:space="preserve"> |
|||
<value>Type mismatch.</value> |
|||
</data> |
|||
<data name="ArgumentVectorLengthsMultipleOf" xml:space="preserve"> |
|||
<value>Array length must be a multiple of {0}.</value> |
|||
</data> |
|||
<data name="ArgumentVectorsSameLengths" xml:space="preserve"> |
|||
<value>All vectors must have the same dimensionality.</value> |
|||
</data> |
|||
<data name="ArgumentVectorThreeDimensional" xml:space="preserve"> |
|||
<value>The vector must have 3 dimensions.</value> |
|||
</data> |
|||
<data name="FeaturePlannedButNotImplementedYet" xml:space="preserve"> |
|||
<value>This feature is not implemented yet (but is planned).</value> |
|||
</data> |
|||
<data name="InvalidLeftBoundaryCondition" xml:space="preserve"> |
|||
<value>Invalid Left Boundary Condition.</value> |
|||
</data> |
|||
<data name="InvalidOperationAccumulatorEmpty" xml:space="preserve"> |
|||
<value>The operation could not be performed because the accumulator is empty.</value> |
|||
</data> |
|||
<data name="InvalidOperationHistogramEmpty" xml:space="preserve"> |
|||
<value>The operation could not be performed because the histogram is empty.</value> |
|||
</data> |
|||
<data name="InvalidOperationHistogramNotEnoughPoints" xml:space="preserve"> |
|||
<value>Not enough points in the distribution.</value> |
|||
</data> |
|||
<data name="InvalidOperationNoSamplesProvided" xml:space="preserve"> |
|||
<value>No Samples Provided. Preparation Required.</value> |
|||
</data> |
|||
<data name="InvalidRightBoundaryCondition" xml:space="preserve"> |
|||
<value>Invalid Right Boundary Condition.</value> |
|||
</data> |
|||
<data name="SpecialCasePlannedButNotImplementedYet" xml:space="preserve"> |
|||
<value>This special case is not supported yet (but is planned).</value> |
|||
</data> |
|||
</root> |
|||
Binary file not shown.
Loading…
Reference in new issue