diff --git a/src/Managed.UnitTests/ComplexTest.cs b/src/Managed.UnitTests/ComplexTest.cs new file mode 100644 index 00000000..3291ff6f --- /dev/null +++ b/src/Managed.UnitTests/ComplexTest.cs @@ -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"); + } + } +} \ No newline at end of file diff --git a/src/Managed/Complex.cs b/src/Managed/Complex.cs new file mode 100644 index 00000000..d433b0b8 --- /dev/null +++ b/src/Managed/Complex.cs @@ -0,0 +1,439 @@ +// +// 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. +// + +namespace MathNet.Numerics +{ + using System; + using System.Runtime.InteropServices; + using System.Text; + using System.Text.RegularExpressions; + using Properties; + + /// + /// Complex numbers class. + /// + /// + /// The class Complex provides all elementary operations + /// on complex numbers. All the operators +, -, + /// *, /, ==, != are defined in the + /// canonical way. Additional complex trigonometric functions such + /// as , ... + /// are also provided. Note that the Complex structures + /// has two special constant values and + /// . + /// In order to avoid possible ambiguities resulting from a + /// Complex(double, double) constructor, the static methods + /// and + /// are provided instead. + /// + /// Complex x = Complex.FromRealImaginary(1d, 2d); + /// Complex y = Complex.FromModulusArgument(1d, Math.Pi); + /// Complex z = (x + y) / (x - y); + /// + /// Since there is no canonical order among the complex numbers, + /// Complex does not implement IComparable but several + /// lexicographic IComparer implementations are provided, see + /// , + /// and + /// . + /// For mathematical details about complex numbers, please + /// have a look at the + /// Wikipedia + /// + [Serializable] + [StructLayout(LayoutKind.Sequential)] + public struct Complex : IFormattable, IEquatable + { + #region fields + + /// + /// Regular expressionused to parse strings into complex numbers. + /// + private static readonly Regex parseExpression = new Regex(@"^((?(([-+]?(\d+\.?\d*|\d*\.?\d+)([Ee][-+]?[0-9]+)?)|(NaN)|([-+]?Infinity)))|(?(([-+]?((\d+\.?\d*|\d*\.?\d+)([Ee][-+]?[0-9]+)?)|(NaN)|([-+]?Infinity))?[i]))|(?(([-+]?(\d+\.?\d*|\d*\.?\d+)([Ee][-+]?[0-9]+)?)|(NaN)|([-+]?Infinity)))(?(([-+]((\d+\.?\d*|\d*\.?\d+)([Ee][-+]?[0-9]+)?)|[-+](NaN)|([-+]Infinity))?[i])))$", RegexOptions.Singleline | RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace); + + /// + /// Represents imaginary unit number. + /// + private static readonly Complex i = new Complex(0, 1); + + /// + /// Represents a infite complex number + /// + private static readonly Complex infinity = new Complex(double.PositiveInfinity, double.PositiveInfinity); + + /// + /// Reprensents not-a-number. + /// + private static readonly Complex nan = new Complex(Double.NaN, Double.NaN); + + /// + /// Representing the one value. + /// + private static readonly Complex one = new Complex(1.0, 0.0); + + /// + /// Representing the zero value. + /// + private static readonly Complex zero = new Complex(0.0, 0.0); + + /// + /// The real component of the complex number. + /// + private readonly double real; + + /// + /// The imaginary component of the complex number. + /// + private readonly double imag; + + #endregion fields + + #region Constructor + + /// + /// Initializes a new instance of the Complex struct with the given real + /// and imaginary parts. + /// + /// The value for the real component. + /// The value for the imaginary component. + public Complex(double real, double imaginary) + { + this.real = real; + this.imag = imaginary; + } + + #endregion + + #region Properties + + /// + /// Gets a value representing the infinity value. This field is constant. + /// + /// The infinity. + /// + /// The semantic associated to this value is a Complex 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. + /// + /// A value representing the infinity value. + public static Complex Infinity + { + get { return infinity; } + } + + /// + /// Gets a value representing not-a-number. This field is constant. + /// + /// A value representing not-a-number. + public static Complex NaN + { + get { return nan; } + } + + /// + /// Gets a value representing the imaginary unit number. This field is constant. + /// + /// A value representing the imaginary unit number. + public static Complex I + { + get { return i; } + } + + /// + /// Gets a value representing the zero value. This field is constant. + /// + /// A value representing the zero value. + public static Complex Zero + { + get { return new Complex(0.0, 0.0); } + } + + /// + /// Gets a value representing the 1 value. This field is constant. + /// + /// A value representing the 1 value. + public static Complex One + { + get { return one; } + } + + #endregion Properties + + /// + /// Gets the real component of the complex number. + /// + /// The real component of the complex number. + public double Real + { + get { return this.real; } + } + + /// + /// Gets the real imaginary component of the complex number. + /// + /// The real imaginary component of the complex number. + public double Imaginary + { + get { return this.imag; } + } + + /// + /// Gets a value indicating whether whether the Complex is zero. + /// + /// true if this instance is zero; otherwise, false. + public bool IsZero + { + get { throw new NotImplementedException(); } // return Number.AlmostZero(real) && Number.AlmostZero(imag); } + } + + /// + /// Gets a value indicating whether the Complex is one. + /// + /// true if this instance is one; otherwise, false. + public bool IsOne + { + get { throw new NotImplementedException(); } // return Number.AlmostEqual(real, 1) && Number.AlmostZero(imag); } + } + + /// + /// Gets a value indicating whether the Complex is the imaginary unit. + /// + /// true if this instance is I; otherwise, false. + public bool IsI + { + get { throw new NotImplementedException(); } // return Number.AlmostZero(real) && Number.AlmostEqual(imag, 1); } + } + + /// + /// Gets a value indicating whether the provided Complex evaluates to a + /// value that is not a number. + /// + /// true if this instance is NaN; otherwise, false. + public bool IsNaN + { + get { throw new NotImplementedException(); } // return double.IsNaN(real) || double.IsNaN(imag); } + } + + /// + /// Gets a value indicating whether the provided Complex evaluates to an + /// infinite value. + /// + /// + /// true if this instance is infinie; otherwise, false. + /// + /// + /// True if it either evaluates to a complex infinity + /// or to a directed infinity. + /// + public bool IsInfinity + { + get { return double.IsInfinity(this.real) || double.IsInfinity(this.imag); } + } + + /// + /// Gets a value indicating whether the provided Complex is real. + /// + /// true if this instance is a real number; otherwise, false. + public bool IsReal + { + get { throw new NotImplementedException(); } // return Number.AlmostZero(imag); } + } + + /// + /// Gets a value indicating whether the provided Complex is real and not negative, that is >= 0. + /// + /// + /// true if this instance is real nonnegative number; otherwise, false. + /// + public bool IsRealNonNegative + { + get { throw new NotImplementedException(); } // return Number.AlmostZero(imag) && real >= 0; } + } + + /// + /// Gets a value indicating whetherthe provided Complex is imaginary. + /// + /// + /// true if this instance is an imaginary number; otherwise, false. + /// + public bool IsImaginary + { + get { throw new NotImplementedException(); } // return Number.AlmostZero(real); } + } + + #region Static Initializers + + /// + /// Constructs a Complex from its real + /// and imaginary parts. + /// + /// The value for the real component. + /// The value for the imaginary component. + /// A new Complex with the given values. + public static Complex FromRealImaginary(double real, double imaginary) + { + return new Complex(real, imaginary); + } + + /// + /// Constructs a Complex from its modulus and + /// argument. + /// + /// Must be non-negative. + /// Real number. + /// A new Complex from the given values. + 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 + + /// A string representation of this complex number. + /// The string representation of this complex number. + public override string ToString() + { + return this.ToString(null, null); + } + + /// A string representation of this complex number. + /// + /// The string representation of this complex number formatted as specified by the + /// format string. + /// + /// A format specification. + public string ToString(string format) + { + return this.ToString(format, null); + } + + /// A string representation of this complex number. + /// + /// The string representation of this complex number formatted as specified by the + /// format provider. + /// + /// An IFormatProvider that supplies culture-specific formatting information. + public string ToString(IFormatProvider formatProvider) + { + return this.ToString(null, formatProvider); + } + + /// A string representation of this complex number. + /// + /// The string representation of this complex number formatted as specified by the + /// format string and format provider. + /// + /// if the n, is not a number. + /// if s, is . + /// A format specification. + /// An IFormatProvider that supplies culture-specific formatting information. + 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 Members + + /// + /// Checks if two complex numbers are equal. Two complex numbers are equal if their + /// corresponding real and imaginary components are equal. + /// + /// + /// Returns true if the two objects are the same object, or if their corresponding + /// real and imaginary components are equal, false otherwise. + /// + /// The complex number to compare to with. + public bool Equals(Complex other) + { + return this.Real == other.Real && this.Imaginary == other.Imaginary; + } + + /// The hash code for the complex number. + /// The hash code of the complex number. + /// + /// The hash code is calculated as + /// System.Math.Exp(ComplexMath.Absolute(complexNumber)). + /// + public override int GetHashCode() + { + return this.real.GetHashCode() ^ (-this.imag.GetHashCode()); + } + + /// + /// Checks if two complex numbers are equal. Two complex numbers are equal if their + /// corresponding real and imaginary components are equal. + /// + /// + /// Returns true if the two objects are the same object, or if their corresponding + /// real and imaginary components are equal, false otherwise. + /// + /// The complex number to compare to with. + public override bool Equals(object obj) + { + return (obj is Complex) && this.Equals((Complex) obj); + } + + #endregion + } +} \ No newline at end of file diff --git a/src/Managed/Properties/AssemblyInfo.cs b/src/Managed/Properties/AssemblyInfo.cs index 98cdf0e1..95d96bb1 100644 --- a/src/Managed/Properties/AssemblyInfo.cs +++ b/src/Managed/Properties/AssemblyInfo.cs @@ -1,10 +1,35 @@ -using System.Reflection; -using System.Runtime.InteropServices; +// +// 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. +// + +using System.Reflection; using System.Resources; +using System.Runtime.InteropServices; -// General Information about an assembly is controlled through the following -// set of attributes. Change these attribute values to modify the information -// associated with an assembly. [assembly: AssemblyTitle("Math.NET Numerics (Managed)")] [assembly: AssemblyDescription("")] [assembly: AssemblyConfiguration("")] @@ -13,25 +38,8 @@ using System.Resources; [assembly: AssemblyCopyright("Copyright © Math.NET Project")] [assembly: AssemblyTrademark("")] [assembly: AssemblyCulture("")] - -// Setting ComVisible to false makes the types in this assembly not visible -// to COM components. If you need to access a type in this assembly from -// COM, set the ComVisible attribute to true on that type. [assembly: ComVisible(false)] - -// The following GUID is for the ID of the typelib if this project is exposed to COM [assembly: Guid("7b66646f-f0ee-425d-9065-910d1937a2df")] - -// Version information for an assembly consists of the following four values: -// -// Major Version -// Minor Version -// Build Number -// Revision -// -// You can specify all the values or you can default the Build and Revision Numbers -// by using the '*' as shown below: -// [assembly: AssemblyVersion("1.0.*")] [assembly: AssemblyVersion("1.0.0.0")] [assembly: AssemblyFileVersion("1.0.0.0")] -[assembly: NeutralResourcesLanguageAttribute("en")] +[assembly: NeutralResourcesLanguage("en")] \ No newline at end of file diff --git a/src/Managed/Properties/Resources.Designer.cs b/src/Managed/Properties/Resources.Designer.cs new file mode 100644 index 00000000..85a80424 --- /dev/null +++ b/src/Managed/Properties/Resources.Designer.cs @@ -0,0 +1,512 @@ +//------------------------------------------------------------------------------ +// +// 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. +// +//------------------------------------------------------------------------------ + +namespace MathNet.Numerics.Properties +{ + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // 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() + { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [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; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture + { + get + { + return resourceCulture; + } + set + { + resourceCulture = value; + } + } + + /// + /// Looks up a localized string similar to The histogram does not contains the value {0}.. + /// + internal static string ArgumentHistogramContainsNot + { + get + { + return ResourceManager.GetString("ArgumentHistogramContainsNot", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Value is expected to be between {0} and {1} (including {0} and {1}).. + /// + internal static string ArgumentInIntervalXYInclusive + { + get + { + return ResourceManager.GetString("ArgumentInIntervalXYInclusive", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The matrix indices must not be out of range of the given matrix.. + /// + internal static string ArgumentMatrixIndexOutOfRange + { + get + { + return ResourceManager.GetString("ArgumentMatrixIndexOutOfRange", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Matrix must not be rank deficient.. + /// + internal static string ArgumentMatrixNotRankDeficient + { + get + { + return ResourceManager.GetString("ArgumentMatrixNotRankDeficient", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Matrix must not be singular.. + /// + internal static string ArgumentMatrixNotSingular + { + get + { + return ResourceManager.GetString("ArgumentMatrixNotSingular", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Matrix column dimensions must agree.. + /// + internal static string ArgumentMatrixSameColumnDimension + { + get + { + return ResourceManager.GetString("ArgumentMatrixSameColumnDimension", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Matrix dimensions must agree.. + /// + internal static string ArgumentMatrixSameDimensions + { + get + { + return ResourceManager.GetString("ArgumentMatrixSameDimensions", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Matrix row dimensions must agree.. + /// + internal static string ArgumentMatrixSameRowDimension + { + get + { + return ResourceManager.GetString("ArgumentMatrixSameRowDimension", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Matrix must have exactly one column.. + /// + internal static string ArgumentMatrixSingleColumn + { + get + { + return ResourceManager.GetString("ArgumentMatrixSingleColumn", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Matrix must have exactly one column and row, thus have only one cell.. + /// + internal static string ArgumentMatrixSingleColumnRow + { + get + { + return ResourceManager.GetString("ArgumentMatrixSingleColumnRow", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Matrix must have exactly one row.. + /// + internal static string ArgumentMatrixSingleRow + { + get + { + return ResourceManager.GetString("ArgumentMatrixSingleRow", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Matrix must be square.. + /// + internal static string ArgumentMatrixSquare + { + get + { + return ResourceManager.GetString("ArgumentMatrixSquare", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Matrix must be symmetric.. + /// + internal static string ArgumentMatrixSymmetric + { + get + { + return ResourceManager.GetString("ArgumentMatrixSymmetric", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Matrix must be symmetric positive definite.. + /// + internal static string ArgumentMatrixSymmetricPositiveDefinite + { + get + { + return ResourceManager.GetString("ArgumentMatrixSymmetricPositiveDefinite", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Value must neither be infinite nor NaN.. + /// + internal static string ArgumentNotInfinityNaN + { + get + { + return ResourceManager.GetString("ArgumentNotInfinityNaN", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Value must not be negative (zero is ok).. + /// + internal static string ArgumentNotNegative + { + get + { + return ResourceManager.GetString("ArgumentNotNegative", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to {0} is a null reference (Nothing in Visual Basic).. + /// + internal static string ArgumentNull + { + get + { + return ResourceManager.GetString("ArgumentNull", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to {0} must be greater than {1}.. + /// + internal static string ArgumentOutOfRangeGreater + { + get + { + return ResourceManager.GetString("ArgumentOutOfRangeGreater", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to {0} must be greater than or equal to {1}.. + /// + internal static string ArgumentOutOfRangeGreaterEqual + { + get + { + return ResourceManager.GetString("ArgumentOutOfRangeGreaterEqual", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The chosen parameter set is invalid (probably some value is out of range).. + /// + internal static string ArgumentParameterSetInvalid + { + get + { + return ResourceManager.GetString("ArgumentParameterSetInvalid", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The given expression does not represent a complex number.. + /// + internal static string ArgumentParseComplexNumber + { + get + { + return ResourceManager.GetString("ArgumentParseComplexNumber", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Value must be positive (and not zero).. + /// + internal static string ArgumentPositive + { + get + { + return ResourceManager.GetString("ArgumentPositive", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Size must be a Power of Two.. + /// + internal static string ArgumentPowerOfTwo + { + get + { + return ResourceManager.GetString("ArgumentPowerOfTwo", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Size must be a Power of Two in every dimension.. + /// + internal static string ArgumentPowerOfTwoEveryDimension + { + get + { + return ResourceManager.GetString("ArgumentPowerOfTwoEveryDimension", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The range between {0} and {1} must be less than or equal to {2}.. + /// + internal static string ArgumentRangeLessEqual + { + get + { + return ResourceManager.GetString("ArgumentRangeLessEqual", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Array must have exactly one dimension (and not be null).. + /// + internal static string ArgumentSingleDimensionArray + { + get + { + return ResourceManager.GetString("ArgumentSingleDimensionArray", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Value is too large.. + /// + internal static string ArgumentTooLarge + { + get + { + return ResourceManager.GetString("ArgumentTooLarge", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Value is too large for the current iteration limit.. + /// + internal static string ArgumentTooLargeForIterationLimit + { + get + { + return ResourceManager.GetString("ArgumentTooLargeForIterationLimit", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Type mismatch.. + /// + internal static string ArgumentTypeMismatch + { + get + { + return ResourceManager.GetString("ArgumentTypeMismatch", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Array length must be a multiple of {0}.. + /// + internal static string ArgumentVectorLengthsMultipleOf + { + get + { + return ResourceManager.GetString("ArgumentVectorLengthsMultipleOf", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to All vectors must have the same dimensionality.. + /// + internal static string ArgumentVectorsSameLengths + { + get + { + return ResourceManager.GetString("ArgumentVectorsSameLengths", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The vector must have 3 dimensions.. + /// + internal static string ArgumentVectorThreeDimensional + { + get + { + return ResourceManager.GetString("ArgumentVectorThreeDimensional", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to This feature is not implemented yet (but is planned).. + /// + internal static string FeaturePlannedButNotImplementedYet + { + get + { + return ResourceManager.GetString("FeaturePlannedButNotImplementedYet", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Invalid Left Boundary Condition.. + /// + internal static string InvalidLeftBoundaryCondition + { + get + { + return ResourceManager.GetString("InvalidLeftBoundaryCondition", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The operation could not be performed because the accumulator is empty.. + /// + internal static string InvalidOperationAccumulatorEmpty + { + get + { + return ResourceManager.GetString("InvalidOperationAccumulatorEmpty", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The operation could not be performed because the histogram is empty.. + /// + internal static string InvalidOperationHistogramEmpty + { + get + { + return ResourceManager.GetString("InvalidOperationHistogramEmpty", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Not enough points in the distribution.. + /// + internal static string InvalidOperationHistogramNotEnoughPoints + { + get + { + return ResourceManager.GetString("InvalidOperationHistogramNotEnoughPoints", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to No Samples Provided. Preparation Required.. + /// + internal static string InvalidOperationNoSamplesProvided + { + get + { + return ResourceManager.GetString("InvalidOperationNoSamplesProvided", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Invalid Right Boundary Condition.. + /// + internal static string InvalidRightBoundaryCondition + { + get + { + return ResourceManager.GetString("InvalidRightBoundaryCondition", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to This special case is not supported yet (but is planned).. + /// + internal static string SpecialCasePlannedButNotImplementedYet + { + get + { + return ResourceManager.GetString("SpecialCasePlannedButNotImplementedYet", resourceCulture); + } + } + } +} diff --git a/src/Managed/Properties/Resources.resx b/src/Managed/Properties/Resources.resx new file mode 100644 index 00000000..d34c3b9b --- /dev/null +++ b/src/Managed/Properties/Resources.resx @@ -0,0 +1,240 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + The histogram does not contains the value {0}. + + + Value is expected to be between {0} and {1} (including {0} and {1}). + + + The matrix indices must not be out of range of the given matrix. + + + Matrix must not be rank deficient. + + + Matrix must not be singular. + + + Matrix column dimensions must agree. + + + Matrix dimensions must agree. + + + Matrix row dimensions must agree. + + + Matrix must have exactly one column. + + + Matrix must have exactly one column and row, thus have only one cell. + + + Matrix must have exactly one row. + + + Matrix must be square. + + + Matrix must be symmetric. + + + Matrix must be symmetric positive definite. + + + Value must neither be infinite nor NaN. + + + Value must not be negative (zero is ok). + + + {0} is a null reference (Nothing in Visual Basic). + + + {0} must be greater than {1}. + + + {0} must be greater than or equal to {1}. + + + The chosen parameter set is invalid (probably some value is out of range). + + + The given expression does not represent a complex number. + + + Value must be positive (and not zero). + + + Size must be a Power of Two. + + + Size must be a Power of Two in every dimension. + + + The range between {0} and {1} must be less than or equal to {2}. + + + Array must have exactly one dimension (and not be null). + + + Value is too large. + + + Value is too large for the current iteration limit. + + + Type mismatch. + + + Array length must be a multiple of {0}. + + + All vectors must have the same dimensionality. + + + The vector must have 3 dimensions. + + + This feature is not implemented yet (but is planned). + + + Invalid Left Boundary Condition. + + + The operation could not be performed because the accumulator is empty. + + + The operation could not be performed because the histogram is empty. + + + Not enough points in the distribution. + + + No Samples Provided. Preparation Required. + + + Invalid Right Boundary Condition. + + + This special case is not supported yet (but is planned). + + \ No newline at end of file diff --git a/src/MathNet.Numerics.snk b/src/MathNet.Numerics.snk new file mode 100644 index 00000000..93e42734 Binary files /dev/null and b/src/MathNet.Numerics.snk differ