//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:2.0.50727.1433
//
//     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", "2.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);
            }
        }
    }
}
