Browse Source

add silverlight project

pull/36/head
Marcus Cuda 17 years ago
parent
commit
1cf455eddc
  1. 1
      src/.gitignore
  2. 6
      src/MathNet.Numerics.sln
  3. 10
      src/Numerics/Complex.cs
  4. 8
      src/Numerics/Complex32.cs
  5. 69
      src/Numerics/GlobalizationHelper.cs
  6. 15
      src/Numerics/LinearAlgebra/Double/Matrix.cs
  7. 15
      src/Numerics/LinearAlgebra/Double/Vector.cs
  8. 2
      src/Numerics/Numerics.csproj
  9. 77
      src/Numerics/Precision.cs
  10. 36
      src/Numerics/Statistics/Histogram.cs
  11. 2
      src/Numerics/Threading/AggregateException.cs
  12. 49
      src/Silverlight/Properties/AssemblyInfo.cs
  13. 576
      src/Silverlight/Properties/Resources.Designer.cs
  14. 291
      src/Silverlight/Properties/Resources.resx
  15. 350
      src/Silverlight/Silverlight.csproj

1
src/.gitignore

@ -1,3 +1,4 @@
Bin
bin
obj
*.user

6
src/MathNet.Numerics.sln

@ -13,6 +13,8 @@ Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "FSharpExamples", "FSharpExa
EndProject
Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "FSharpUnitTests", "FSharpUnitTests\FSharpUnitTests.fsproj", "{F2F8032B-A31D-4E33-A05E-F2CDCBFAA75D}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Silverlight", "Silverlight\Silverlight.csproj", "{0CCA2BA4-9DF2-4E9B-8A77-0A1F61A96A77}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@ -43,6 +45,10 @@ Global
{F2F8032B-A31D-4E33-A05E-F2CDCBFAA75D}.Debug|Any CPU.Build.0 = Debug|Any CPU
{F2F8032B-A31D-4E33-A05E-F2CDCBFAA75D}.Release|Any CPU.ActiveCfg = Release|Any CPU
{F2F8032B-A31D-4E33-A05E-F2CDCBFAA75D}.Release|Any CPU.Build.0 = Release|Any CPU
{0CCA2BA4-9DF2-4E9B-8A77-0A1F61A96A77}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{0CCA2BA4-9DF2-4E9B-8A77-0A1F61A96A77}.Debug|Any CPU.Build.0 = Debug|Any CPU
{0CCA2BA4-9DF2-4E9B-8A77-0A1F61A96A77}.Release|Any CPU.ActiveCfg = Release|Any CPU
{0CCA2BA4-9DF2-4E9B-8A77-0A1F61A96A77}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

10
src/Numerics/Complex.cs

@ -67,7 +67,9 @@ namespace MathNet.Numerics
/// Wikipedia</a>
/// </para>
/// </remarks>
#if !SILVERLIGHT
[Serializable]
#endif
[StructLayout(LayoutKind.Sequential)]
public struct Complex : IFormattable, IEquatable<Complex>, IPrecisionSupport<Complex>
{
@ -566,7 +568,7 @@ namespace MathNet.Numerics
{
if (modulus < 0.0)
{
throw new ArgumentOutOfRangeException("modulus", modulus, Resources.ArgumentNotNegative);
throw new ArgumentOutOfRangeException("modulus", Resources.ArgumentNotNegative);
}
return new Complex(modulus * Math.Cos(argument), modulus * Math.Sin(argument));
@ -1198,7 +1200,11 @@ namespace MathNet.Numerics
}
}
double value = GlobalizationHelper.ParseDouble(ref token, format.GetCultureInfo());
#if SILVERLIGHT
var value = GlobalizationHelper.ParseDouble(ref token);
#else
var value = GlobalizationHelper.ParseDouble(ref token, format.GetCultureInfo());
#endif
// handle suffix imaginary symbol
if (token != null && (String.Compare(token.Value, "i", StringComparison.OrdinalIgnoreCase) == 0

8
src/Numerics/Complex32.cs

@ -67,7 +67,9 @@ namespace MathNet.Numerics
/// Wikipedia</a>
/// </para>
/// </remarks>
#if !SILVERLIGHT
[Serializable]
#endif
[StructLayout(LayoutKind.Sequential)]
public struct Complex32 : IFormattable, IEquatable<Complex32>, IPrecisionSupport<Complex32>
{
@ -566,7 +568,7 @@ namespace MathNet.Numerics
{
if (modulus < 0.0f)
{
throw new ArgumentOutOfRangeException("modulus", modulus, Resources.ArgumentNotNegative);
throw new ArgumentOutOfRangeException("modulus", Resources.ArgumentNotNegative);
}
return new Complex32(modulus * (float)Math.Cos(argument), modulus * (float)Math.Sin(argument));
@ -1198,7 +1200,11 @@ namespace MathNet.Numerics
}
}
#if SILVERLIGHT
var value = GlobalizationHelper.ParseSingle(ref token);
#else
var value = GlobalizationHelper.ParseSingle(ref token, format.GetCultureInfo());
#endif
// handle suffix imaginary symbol
if (token != null && (String.Compare(token.Value, "i", StringComparison.OrdinalIgnoreCase) == 0

69
src/Numerics/GlobalizationHelper.cs

@ -125,6 +125,74 @@ namespace MathNet.Numerics
}
}
#if SILVERLIGHT
/// <summary>
/// Globalized Parsing: Parse a double number
/// </summary>
/// <param name="token">First token of the number.</param>
/// <returns>The parsed double number using the current culture information.</returns>
/// <exception cref="FormatException" />
internal static double ParseDouble(ref LinkedListNode<string> token)
{
// in case the + and - in scientific notation are separated, join them back together.
if (token.Value.EndsWith("e", StringComparison.CurrentCultureIgnoreCase))
{
if (token.Next == null || token.Next.Next == null)
{
throw new FormatException();
}
token.Value = token.Value + token.Next.Value + token.Next.Next.Value;
var list = token.List;
list.Remove(token.Next.Next);
list.Remove(token.Next);
}
double value;
if (!Double.TryParse(token.Value, NumberStyles.Any, CultureInfo.CurrentCulture, out value))
{
throw new FormatException();
}
token = token.Next;
return value;
}
/// <summary>
/// Globalized Parsing: Parse a float number
/// </summary>
/// <param name="token">First token of the number.</param>
/// <returns>The parsed float number using the current culture information.</returns>
/// <exception cref="FormatException" />
internal static float ParseSingle(ref LinkedListNode<string> token)
{
// in case the + and - in scientific notation are separated, join them back together.
if (token.Value.EndsWith("e", StringComparison.CurrentCultureIgnoreCase))
{
if (token.Next == null || token.Next.Next == null)
{
throw new FormatException();
}
token.Value = token.Value + token.Next.Value + token.Next.Next.Value;
var list = token.List;
list.Remove(token.Next.Next);
list.Remove(token.Next);
}
float value;
if (!Single.TryParse(token.Value, NumberStyles.Any, CultureInfo.CurrentCulture, out value))
{
throw new FormatException();
}
token = token.Next;
return value;
}
#else
/// <summary>
/// Globalized Parsing: Parse a double number
/// </summary>
@ -192,5 +260,6 @@ namespace MathNet.Numerics
token = token.Next;
return value;
}
#endif
}
}

15
src/Numerics/LinearAlgebra/Double/Matrix.cs

@ -36,8 +36,15 @@ namespace MathNet.Numerics.LinearAlgebra.Double
/// <summary>
/// Defines the base class for <c>Matrix</c> classes.
/// </summary>
#if !SILVERLIGHT
[Serializable]
public abstract class Matrix : IFormattable, ICloneable, IEquatable<Matrix>
#endif
public abstract class Matrix :
#if SILVERLIGHT
IFormattable, IEquatable<Matrix>
#else
IFormattable, IEquatable<Matrix>, ICloneable
#endif
{
/// <summary>
/// Initializes a new instance of the <see cref="Matrix"/> class.
@ -237,6 +244,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double
#region Implemented Interfaces
#if !SILVERLIGHT
#region ICloneable
/// <summary>
@ -251,6 +259,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double
}
#endregion
#endif
#region IEquatable<Matrix>
@ -391,7 +400,11 @@ namespace MathNet.Numerics.LinearAlgebra.Double
var col = i % ColumnCount;
var row = (i - col) / RowCount;
#if SILVERLIGHT
hash ^= Precision.DoubleToInt64Bits(this[row, col]);
#else
hash ^= BitConverter.DoubleToInt64Bits(this[row, col]);
#endif
}
return BitConverter.ToInt32(BitConverter.GetBytes(hash), 4);

15
src/Numerics/LinearAlgebra/Double/Vector.cs

@ -39,8 +39,15 @@ namespace MathNet.Numerics.LinearAlgebra.Double
/// <summary>
/// Defines the base class for <c>Vector</c> classes.
/// </summary>
#if !SILVERLIGHT
[Serializable]
public abstract class Vector : IFormattable, IEnumerable<double>, ICloneable, IEquatable<Vector>
#endif
public abstract class Vector :
#if SILVERLIGHT
IFormattable, IEnumerable<double>, IEquatable<Vector>
#else
IFormattable, IEnumerable<double>, IEquatable<Vector>, ICloneable
#endif
{
/// <summary>
/// Initializes a new instance of the <see cref="Vector"/> class.
@ -781,6 +788,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double
#region Implemented Interfaces
#if !SILVERLIGHT
#region ICloneable
/// <summary>
@ -795,6 +803,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double
}
#endregion
#endif
#region IEnumerable
@ -946,7 +955,11 @@ namespace MathNet.Numerics.LinearAlgebra.Double
long hash = 0;
for (var i = 0; i < hashNum; i++)
{
#if SILVERLIGHT
hash ^= Precision.DoubleToInt64Bits(this[i]);
#else
hash ^= BitConverter.DoubleToInt64Bits(this[i]);
#endif
}
return BitConverter.ToInt32(BitConverter.GetBytes(hash), 4);

2
src/Numerics/Numerics.csproj

@ -20,7 +20,7 @@
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<DefineConstants>TRACE;DEBUG</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<DocumentationFile>

77
src/Numerics/Precision.cs

@ -183,10 +183,18 @@ namespace MathNet.Numerics
// truncating a negative number will give us a magnitude that is off by 1
if (magnitude < 0)
{
#if SILVERLIGHT
return (int)Truncate(magnitude - 1);
#else
return (int)Math.Truncate(magnitude - 1);
#endif
}
#if SILVERLIGHT
return (int)Truncate(magnitude);
#else
return (int)Math.Truncate(magnitude);
#endif
}
/// <summary>
@ -214,7 +222,11 @@ namespace MathNet.Numerics
/// </returns>
private static long GetLongFromDouble(double value)
{
#if SILVERLIGHT
return DoubleToInt64Bits(value);
#else
return BitConverter.DoubleToInt64Bits(value);
#endif
}
/// <summary>
@ -295,7 +307,11 @@ namespace MathNet.Numerics
// Note that not all long values can be translated into double values. There's a whole bunch of them
// which return weird values like infinity and NaN
#if SILVERLIGHT
return Int64BitsToDouble(intValue);
#else
return BitConverter.Int64BitsToDouble(intValue);
#endif
}
/// <summary>
@ -361,7 +377,11 @@ namespace MathNet.Numerics
// Note that not all long values can be translated into double values. There's a whole bunch of them
// which return weird values like infinity and NaN
#if SILVERLIGHT
return Int64BitsToDouble(intValue);
#else
return BitConverter.Int64BitsToDouble(intValue);
#endif
}
/// <summary>
@ -504,12 +524,20 @@ namespace MathNet.Numerics
// Got underflow, which can be fixed by splitting the calculation into two bits
// first get the remainder of the intValue after subtracting it from the long.MinValue
// and add that to the ulpsDifference. That way we'll turn positive without underflow
#if SILVERLIGHT
topRangeEnd =Int64BitsToDouble(maxNumbersBetween + (long.MinValue - intValue));
#else
topRangeEnd = BitConverter.Int64BitsToDouble(maxNumbersBetween + (long.MinValue - intValue));
#endif
}
else
{
// No problems here, move along.
#if SILVERLIGHT
topRangeEnd = Int64BitsToDouble(intValue - maxNumbersBetween);
#else
topRangeEnd = BitConverter.Int64BitsToDouble(intValue - maxNumbersBetween);
#endif
}
if (Math.Abs(intValue) < maxNumbersBetween)
@ -522,7 +550,11 @@ namespace MathNet.Numerics
{
// intValue is negative. Adding the positive ulpsDifference means that it gets less negative.
// However due to the conversion way this means that the actual double value gets more negative :-S
#if SILVERLIGHT
bottomRangeEnd =Int64BitsToDouble(intValue + maxNumbersBetween);
#else
bottomRangeEnd = BitConverter.Int64BitsToDouble(intValue + maxNumbersBetween);
#endif
}
}
else
@ -537,7 +569,11 @@ namespace MathNet.Numerics
else
{
// No troubles here
#if SILVERLIGHT
topRangeEnd = Int64BitsToDouble(intValue + maxNumbersBetween);
#else
topRangeEnd = BitConverter.Int64BitsToDouble(intValue + maxNumbersBetween);
#endif
}
// Check the bottom range end for underflows
@ -545,13 +581,21 @@ namespace MathNet.Numerics
{
// No problems here. IntValue is larger than ulpsDifference so we'll end up with a
// positive number.
#if SILVERLIGHT
bottomRangeEnd =Int64BitsToDouble(intValue - maxNumbersBetween);
#else
bottomRangeEnd = BitConverter.Int64BitsToDouble(intValue - maxNumbersBetween);
#endif
}
else
{
// Int value is bigger than zero but smaller than the ulpsDifference. So we'll need to deal with
// the reversal at the negative end
#if SILVERLIGHT
bottomRangeEnd = Int64BitsToDouble(long.MinValue + (maxNumbersBetween - intValue));
#else
bottomRangeEnd = BitConverter.Int64BitsToDouble(long.MinValue + (maxNumbersBetween - intValue));
#endif
}
}
}
@ -1416,19 +1460,36 @@ namespace MathNet.Numerics
return double.NaN;
}
#if SILVERLIGHT
long signed64 = DoubleToInt64Bits(value);
#else
long signed64 = BitConverter.DoubleToInt64Bits(value);
#endif
if (signed64 == 0)
{
signed64++;
#if SILVERLIGHT
return Int64BitsToDouble(signed64) - value;
#else
return BitConverter.Int64BitsToDouble(signed64) - value;
#endif
}
if (signed64-- < 0)
{
#if SILVERLIGHT
return Int64BitsToDouble(signed64) - value;
#else
return BitConverter.Int64BitsToDouble(signed64) - value;
#endif
}
#if SILVERLIGHT
return value - Int64BitsToDouble(signed64);
#else
return value - BitConverter.Int64BitsToDouble(signed64);
#endif
}
/// <summary>
@ -1442,5 +1503,21 @@ namespace MathNet.Numerics
{
return 2 * EpsilonOf(value);
}
#if SILVERLIGHT
internal static long DoubleToInt64Bits(double value)
{
return BitConverter.ToInt64(BitConverter.GetBytes(value), 0);
}
internal static double Int64BitsToDouble(long value)
{
return BitConverter.ToDouble(BitConverter.GetBytes(value), 0);
}
internal static double Truncate(double value){
return value >= 0.0 ? Math.Floor(value) : Math.Ceiling(value);
}
#endif
}
}

36
src/Numerics/Statistics/Histogram.cs

@ -29,16 +29,23 @@
namespace MathNet.Numerics.Statistics
{
using System;
using System.Text;
using System.Collections.Generic;
using System.Text;
using Properties;
/// <summary>
/// A <see cref="Histogram"/> consists of a series of <see cref="Bucket"/>s,
/// each representing a region limited by a lower bound (exclusive) and an upper bound (inclusive).
/// </summary>
#if !SILVERLIGHT
[Serializable]
public class Bucket : IComparable<Bucket>, ICloneable
#endif
public class Bucket :
#if SILVERLIGHT
IComparable<Bucket>
#else
IComparable<Bucket>, ICloneable
#endif
{
/// <summary>
/// This <c>IComparer</c> performs comparisons between a point and a bucket.
@ -64,7 +71,7 @@ namespace MathNet.Numerics.Statistics
}
}
static PointComparer pointComparer = new PointComparer();
private static PointComparer pointComparer = new PointComparer();
/// <summary>
/// Lower Bound of the Bucket.
@ -112,7 +119,7 @@ namespace MathNet.Numerics.Statistics
/// Creates a copy of the Bucket with the lowerbound, upperbound and counts exactly equal.
/// </summary>
/// <returns>A cloned Bucket object.</returns>
public Object Clone()
public object Clone()
{
return new Bucket(LowerBound, UpperBound, Count);
}
@ -159,7 +166,7 @@ namespace MathNet.Numerics.Statistics
/// </summary>
public int CompareTo(Bucket bucket)
{
if(this.UpperBound > bucket.LowerBound && this.LowerBound < bucket.LowerBound)
if (this.UpperBound > bucket.LowerBound && this.LowerBound < bucket.LowerBound)
{
throw new ArgumentException(Resources.PartialOrderException);
}
@ -216,18 +223,20 @@ namespace MathNet.Numerics.Statistics
/// <summary>
/// A class which computes histograms of data.
/// </summary>
#if !SILVERLIGHT
[Serializable]
#endif
public class Histogram
{
/// <summary>
/// Contains all the <c>Bucket</c>s of the <c>Histogram</c>.
/// </summary>
List<Bucket> buckets;
private List<Bucket> buckets;
/// <summary>
/// Indicates whether the elements of <c>buckets</c> are currently sorted.
/// </summary>
bool areBucketsSorted;
private bool areBucketsSorted;
/// <summary>
/// Initializes a new instance of the Histogram class.
@ -281,6 +290,7 @@ namespace MathNet.Numerics.Statistics
{
throw new ArgumentOutOfRangeException("The histogram lowerbound must be smaller than the upper bound.");
}
if (nbuckets < 1)
{
throw new ArgumentOutOfRangeException("The number of bins in a histogram should be at least 1.");
@ -380,9 +390,9 @@ namespace MathNet.Numerics.Statistics
LazySort();
// Binary search for the bucket index.
int index = buckets.BinarySearch(new Bucket(v,v), Bucket.DefaultPointComparer);
int index = buckets.BinarySearch(new Bucket(v, v), Bucket.DefaultPointComparer);
if(index < 0)
if (index < 0)
{
throw new ArgumentException(Resources.ArgumentHistogramContainsNot);
}
@ -410,7 +420,7 @@ namespace MathNet.Numerics.Statistics
get
{
LazySort();
return buckets[buckets.Count-1].UpperBound;
return buckets[buckets.Count - 1].UpperBound;
}
}
@ -444,7 +454,8 @@ namespace MathNet.Numerics.Statistics
get
{
double totalCount = 0;
for(int i = 0; i < this.BucketCount; i++)
for (int i = 0; i < this.BucketCount; i++)
{
totalCount += this[i].Count;
}
@ -459,7 +470,8 @@ namespace MathNet.Numerics.Statistics
public override string ToString()
{
StringBuilder sb = new StringBuilder();
foreach(Bucket b in buckets)
foreach (Bucket b in buckets)
{
sb.Append(b.ToString());
}

2
src/Numerics/Threading/AggregateException.cs

@ -35,7 +35,9 @@ namespace MathNet.Numerics.Threading
/// <summary>
/// Represents multiple errors that occur during application execution.
/// </summary>
#if !SILVERLIGHT
[Serializable]
#endif
public class AggregateException : Exception
{
/// <summary>

49
src/Silverlight/Properties/AssemblyInfo.cs

@ -0,0 +1,49 @@
// <copyright file="AssemblyInfo.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>
using System;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
[assembly: AssemblyTitle("Math.NET Numerics for Silverlight")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Math.NET Project")]
[assembly: AssemblyProduct("Math.NET Numerics")]
[assembly: AssemblyCopyright("Copyright © Math.NET Project")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
[assembly: CLSCompliant(true)]
[assembly: ComVisible(false)]
[assembly: Guid("7b66646f-f0ee-425d-9065-910d1937a2df")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: NeutralResourcesLanguage("en")]
[assembly: InternalsVisibleTo("MathNet.Numerics.UnitTests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100ed2314a577643d859571b8b9307c6ff2670525c4598fbb307e57ea65ebf5d4417284cb3da9181636480b623f4db8cc3c1947244ba069df0df86e2431621f51a488f9929519a1c5d0ae595f6e2d0e4094685f0c1229ff658360acbb9f63f1a0258e984dda00dc7ad4fd16dbb550ec1ef8a11df138402b7c1998ee224e652c839b")]

576
src/Silverlight/Properties/Resources.Designer.cs

@ -0,0 +1,576 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
// Runtime Version:2.0.50727.4927
//
// 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 argument must be between 0 and 1..
/// </summary>
internal static string ArgumentBetween0And1 {
get {
return ResourceManager.GetString("ArgumentBetween0And1", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Value cannot be in the range -1 &lt; x &lt; 1..
/// </summary>
internal static string ArgumentCannotBeBetweenOneAndNegativeOne {
get {
return ResourceManager.GetString("ArgumentCannotBeBetweenOneAndNegativeOne", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Value must be even..
/// </summary>
internal static string ArgumentEven {
get {
return ResourceManager.GetString("ArgumentEven", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The histogram does not contains the value..
/// </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 At least one item of {0} is a null reference (Nothing in Visual Basic)..
/// </summary>
internal static string ArgumentItemNull {
get {
return ResourceManager.GetString("ArgumentItemNull", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Value must be greater than or equal to one..
/// </summary>
internal static string ArgumentLessThanOne {
get {
return ResourceManager.GetString("ArgumentLessThanOne", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to han the given upper bound..
/// </summary>
internal static string ArgumentLowerBoundLargerThanUpperBound {
get {
return ResourceManager.GetString("ArgumentLowerBoundLargerThanUpperBound", 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 In the specified range, the minimum is greater than maximum..
/// </summary>
internal static string ArgumentMinValueGreaterThanMaxValue {
get {
return ResourceManager.GetString("ArgumentMinValueGreaterThanMaxValue", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to Value must be positive..
/// </summary>
internal static string ArgumentMustBePositive {
get {
return ResourceManager.GetString("ArgumentMustBePositive", 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 Value must be odd..
/// </summary>
internal static string ArgumentOdd {
get {
return ResourceManager.GetString("ArgumentOdd", 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 ArgumentVectorsSameLength {
get {
return ResourceManager.GetString("ArgumentVectorsSameLength", 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 The supplied collection is empty..
/// </summary>
internal static string CollectionEmpty {
get {
return ResourceManager.GetString("CollectionEmpty", 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 parameterization for the distribution..
/// </summary>
internal static string InvalidDistributionParameters {
get {
return ResourceManager.GetString("InvalidDistributionParameters", 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 The number of columns of a matrix must be positive..
/// </summary>
internal static string MatrixColumnsMustBePositive {
get {
return ResourceManager.GetString("MatrixColumnsMustBePositive", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The number of rows of a matrix must be positive..
/// </summary>
internal static string MatrixRowsMustBePositive {
get {
return ResourceManager.GetString("MatrixRowsMustBePositive", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The number of rows or columns of a matrix must be positive..
/// </summary>
internal static string MatrixRowsOrColumnsMustBePositive {
get {
return ResourceManager.GetString("MatrixRowsOrColumnsMustBePositive", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The two arguments can&apos;t be compared (maybe they are part of a partial ordering?).
/// </summary>
internal static string PartialOrderException {
get {
return ResourceManager.GetString("PartialOrderException", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The sampler&apos;s proposal distribution is not upper bounding the target density..
/// </summary>
internal static string ProposalDistributionNoUpperBound {
get {
return ResourceManager.GetString("ProposalDistributionNoUpperBound", 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);
}
}
/// <summary>
/// Looks up a localized string similar to A user defined provider has not been specified..
/// </summary>
internal static string UserDefinedProviderNotSpecified {
get {
return ResourceManager.GetString("UserDefinedProviderNotSpecified", resourceCulture);
}
}
}
}

291
src/Silverlight/Properties/Resources.resx

@ -0,0 +1,291 @@
<?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.</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="ArgumentVectorsSameLength" 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>
<data name="InvalidDistributionParameters" xml:space="preserve">
<value>Invalid parameterization for the distribution.</value>
</data>
<data name="ArgumentEven" xml:space="preserve">
<value>Value must be even.</value>
</data>
<data name="ArgumentOdd" xml:space="preserve">
<value>Value must be odd.</value>
</data>
<data name="ArgumentItemNull" xml:space="preserve">
<value>At least one item of {0} is a null reference (Nothing in Visual Basic).</value>
</data>
<data name="CollectionEmpty" xml:space="preserve">
<value>The supplied collection is empty.</value>
</data>
<data name="ArgumentCannotBeBetweenOneAndNegativeOne" xml:space="preserve">
<value>Value cannot be in the range -1 &lt; x &lt; 1.</value>
</data>
<data name="ArgumentLessThanOne" xml:space="preserve">
<value>Value must be greater than or equal to one.</value>
</data>
<data name="ArgumentMustBePositive" xml:space="preserve">
<value>Value must be positive.</value>
</data>
<data name="UserDefinedProviderNotSpecified" xml:space="preserve">
<value>A user defined provider has not been specified.</value>
</data>
<data name="ArgumentMinValueGreaterThanMaxValue" xml:space="preserve">
<value>In the specified range, the minimum is greater than maximum.</value>
</data>
<data name="ArgumentLowerBoundLargerThanUpperBound" xml:space="preserve">
<value>han the given upper bound.</value>
</data>
<data name="PartialOrderException" xml:space="preserve">
<value>The two arguments can't be compared (maybe they are part of a partial ordering?)</value>
</data>
<data name="MatrixColumnsMustBePositive" xml:space="preserve">
<value>The number of columns of a matrix must be positive.</value>
</data>
<data name="MatrixRowsMustBePositive" xml:space="preserve">
<value>The number of rows of a matrix must be positive.</value>
</data>
<data name="MatrixRowsOrColumnsMustBePositive" xml:space="preserve">
<value>The number of rows or columns of a matrix must be positive.</value>
</data>
<data name="ArgumentBetween0And1" xml:space="preserve">
<value>The argument must be between 0 and 1.</value>
</data>
<data name="ProposalDistributionNoUpperBound" xml:space="preserve">
<value>The sampler's proposal distribution is not upper bounding the target density.</value>
</data>
</root>

350
src/Silverlight/Silverlight.csproj

@ -0,0 +1,350 @@
<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.30729</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{0CCA2BA4-9DF2-4E9B-8A77-0A1F61A96A77}</ProjectGuid>
<ProjectTypeGuids>{A1591282-1198-4647-A2B1-27E5FF5F6F3B};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}</ProjectTypeGuids>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>MathNet.Numerics</RootNamespace>
<AssemblyName>MathNet.Numerics.Silverlight</AssemblyName>
<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
<SilverlightApplication>false</SilverlightApplication>
<ValidateXaml>true</ValidateXaml>
<ThrowErrorsInValidation>true</ThrowErrorsInValidation>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>Bin\Debug</OutputPath>
<DefineConstants>DEBUG;TRACE;SILVERLIGHT</DefineConstants>
<NoStdLib>true</NoStdLib>
<NoConfig>true</NoConfig>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>Bin\Release</OutputPath>
<DefineConstants>TRACE;SILVERLIGHT</DefineConstants>
<NoStdLib>true</NoStdLib>
<NoConfig>true</NoConfig>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="System.Windows" />
<Reference Include="mscorlib" />
<Reference Include="system" />
<Reference Include="System.Core" />
<Reference Include="System.Xml" />
<Reference Include="System.Net" />
<Reference Include="System.Windows.Browser" />
</ItemGroup>
<ItemGroup>
<Compile Include="..\Numerics\Algorithms\LinearAlgebra\ILinearAlgebraProvider.cs">
<Link>Algorithms\ILinearAlgebraProvider.cs</Link>
</Compile>
<Compile Include="..\Numerics\Algorithms\LinearAlgebra\ILinearAlgebraProviderOfT.cs">
<Link>Algorithms\ILinearAlgebraProviderOfT.cs</Link>
</Compile>
<Compile Include="..\Numerics\Algorithms\LinearAlgebra\ManagedLinearAlgebraProvider.cs">
<Link>Algorithms\ManagedLinearAlgebraProvider.cs</Link>
</Compile>
<Compile Include="..\Numerics\Combinatorics.cs">
<Link>Combinatorics.cs</Link>
</Compile>
<Compile Include="..\Numerics\Complex.cs">
<Link>Complex.cs</Link>
</Compile>
<Compile Include="..\Numerics\Complex32.cs">
<Link>Complex32.cs</Link>
</Compile>
<Compile Include="..\Numerics\Constants.cs">
<Link>Constants.cs</Link>
</Compile>
<Compile Include="..\Numerics\Control.cs">
<Link>Control.cs</Link>
</Compile>
<Compile Include="..\Numerics\Distributions\Continuous\Beta.cs">
<Link>Distributions\Continuous\Beta.cs</Link>
</Compile>
<Compile Include="..\Numerics\Distributions\Continuous\ContinuousUniform.cs">
<Link>Distributions\Continuous\ContinuousUniform.cs</Link>
</Compile>
<Compile Include="..\Numerics\Distributions\Continuous\Gamma.cs">
<Link>Distributions\Continuous\Gamma.cs</Link>
</Compile>
<Compile Include="..\Numerics\Distributions\Continuous\LogNormal.cs">
<Link>Distributions\Continuous\LogNormal.cs</Link>
</Compile>
<Compile Include="..\Numerics\Distributions\Continuous\Normal.cs">
<Link>Distributions\Continuous\Normal.cs</Link>
</Compile>
<Compile Include="..\Numerics\Distributions\Continuous\Weibull.cs">
<Link>Distributions\Continuous\Weibull.cs</Link>
</Compile>
<Compile Include="..\Numerics\Distributions\Discrete\Bernoulli.cs">
<Link>Distributions\Discrete\Bernoulli.cs</Link>
</Compile>
<Compile Include="..\Numerics\Distributions\Discrete\Binomial.cs">
<Link>Distributions\Discrete\Binomial.cs</Link>
</Compile>
<Compile Include="..\Numerics\Distributions\Discrete\Categorical.cs">
<Link>Distributions\Discrete\Categorical.cs</Link>
</Compile>
<Compile Include="..\Numerics\Distributions\Discrete\DiscreteUniform.cs">
<Link>Distributions\Discrete\DiscreteUniform.cs</Link>
</Compile>
<Compile Include="..\Numerics\Distributions\IContinuousDistribution.cs">
<Link>Distributions\IContinuousDistribution.cs</Link>
</Compile>
<Compile Include="..\Numerics\Distributions\IDiscreteDistribution.cs">
<Link>Distributions\IDiscreteDistribution.cs</Link>
</Compile>
<Compile Include="..\Numerics\Distributions\IDistribution.cs">
<Link>Distributions\IDistribution.cs</Link>
</Compile>
<Compile Include="..\Numerics\Distributions\Multivariate\Dirichlet.cs">
<Link>Distributions\Multivariate\Dirichlet.cs</Link>
</Compile>
<Compile Include="..\Numerics\Distributions\Multivariate\Multinomial.cs">
<Link>Distributions\Multivariate\Multinomial.cs</Link>
</Compile>
<Compile Include="..\Numerics\GlobalizationHelper.cs">
<Link>GlobalizationHelper.cs</Link>
</Compile>
<Compile Include="..\Numerics\IntegralTransforms\Algorithms\DiscreteFourierTransform.Bluestein.cs">
<Link>IntegralTransforms\Algorithms\DiscreteFourierTransform.Bluestein.cs</Link>
</Compile>
<Compile Include="..\Numerics\IntegralTransforms\Algorithms\DiscreteFourierTransform.Naive.cs">
<Link>IntegralTransforms\Algorithms\DiscreteFourierTransform.Naive.cs</Link>
</Compile>
<Compile Include="..\Numerics\IntegralTransforms\Algorithms\DiscreteFourierTransform.Options.cs">
<Link>IntegralTransforms\Algorithms\DiscreteFourierTransform.Options.cs</Link>
</Compile>
<Compile Include="..\Numerics\IntegralTransforms\Algorithms\DiscreteFourierTransform.RadixN.cs">
<Link>IntegralTransforms\Algorithms\DiscreteFourierTransform.RadixN.cs</Link>
</Compile>
<Compile Include="..\Numerics\IntegralTransforms\Algorithms\DiscreteHartleyTransform.Naive.cs">
<Link>IntegralTransforms\Algorithms\DiscreteHartleyTransform.Naive.cs</Link>
</Compile>
<Compile Include="..\Numerics\IntegralTransforms\Algorithms\DiscreteHartleyTransform.Options.cs">
<Link>IntegralTransforms\Algorithms\DiscreteHartleyTransform.Options.cs</Link>
</Compile>
<Compile Include="..\Numerics\IntegralTransforms\FourierOptions.cs">
<Link>IntegralTransforms\FourierOptions.cs</Link>
</Compile>
<Compile Include="..\Numerics\IntegralTransforms\HartleyOptions.cs">
<Link>IntegralTransforms\HartleyOptions.cs</Link>
</Compile>
<Compile Include="..\Numerics\IntegralTransforms\Transform.cs">
<Link>IntegralTransforms\Transform.cs</Link>
</Compile>
<Compile Include="..\Numerics\Integration\Algorithms\DoubleExponentialTransformation.cs">
<Link>Integration\Algorithms\DoubleExponentialTransformation.cs</Link>
</Compile>
<Compile Include="..\Numerics\Integration\Algorithms\NewtonCotesTrapeziumRule.cs">
<Link>Integration\Algorithms\NewtonCotesTrapeziumRule.cs</Link>
</Compile>
<Compile Include="..\Numerics\Integration\Algorithms\SimpsonRule.cs">
<Link>Integration\Algorithms\SimpsonRule.cs</Link>
</Compile>
<Compile Include="..\Numerics\Integration\Integrate.cs">
<Link>Integration\Integrate.cs</Link>
</Compile>
<Compile Include="..\Numerics\Interpolation\Algorithms\AkimaSplineInterpolation.cs">
<Link>Interpolation\Algorithms\AkimaSplineInterpolation.cs</Link>
</Compile>
<Compile Include="..\Numerics\Interpolation\Algorithms\BarycentricInterpolation.cs">
<Link>Interpolation\Algorithms\BarycentricInterpolation.cs</Link>
</Compile>
<Compile Include="..\Numerics\Interpolation\Algorithms\BulirschStoerRationalInterpolation.cs">
<Link>Interpolation\Algorithms\BulirschStoerRationalInterpolation.cs</Link>
</Compile>
<Compile Include="..\Numerics\Interpolation\Algorithms\CubicHermiteSplineInterpolation.cs">
<Link>Interpolation\Algorithms\CubicHermiteSplineInterpolation.cs</Link>
</Compile>
<Compile Include="..\Numerics\Interpolation\Algorithms\CubicSplineInterpolation.cs">
<Link>Interpolation\Algorithms\CubicSplineInterpolation.cs</Link>
</Compile>
<Compile Include="..\Numerics\Interpolation\Algorithms\EquidistantPolynomialInterpolation.cs">
<Link>Interpolation\Algorithms\EquidistantPolynomialInterpolation.cs</Link>
</Compile>
<Compile Include="..\Numerics\Interpolation\Algorithms\FloaterHormannRationalInterpolation.cs">
<Link>Interpolation\Algorithms\FloaterHormannRationalInterpolation.cs</Link>
</Compile>
<Compile Include="..\Numerics\Interpolation\Algorithms\LinearSplineInterpolation.cs">
<Link>Interpolation\Algorithms\LinearSplineInterpolation.cs</Link>
</Compile>
<Compile Include="..\Numerics\Interpolation\Algorithms\NevillePolynomialInterpolation.cs">
<Link>Interpolation\Algorithms\NevillePolynomialInterpolation.cs</Link>
</Compile>
<Compile Include="..\Numerics\Interpolation\Algorithms\SplineInterpolation.cs">
<Link>Interpolation\Algorithms\SplineInterpolation.cs</Link>
</Compile>
<Compile Include="..\Numerics\Interpolation\IInterpolation.cs">
<Link>Interpolation\IInterpolation.cs</Link>
</Compile>
<Compile Include="..\Numerics\Interpolation\Interpolate.cs">
<Link>Interpolation\Interpolate.cs</Link>
</Compile>
<Compile Include="..\Numerics\Interpolation\SplineBoundaryCondition.cs">
<Link>Interpolation\SplineBoundaryCondition.cs</Link>
</Compile>
<Compile Include="..\Numerics\IPrecisionSupport.cs">
<Link>IPrecisionSupport.cs</Link>
</Compile>
<Compile Include="..\Numerics\LinearAlgebra\Double\DenseMatrix.cs">
<Link>LinearAlgebra\Double\DenseMatrix.cs</Link>
</Compile>
<Compile Include="..\Numerics\LinearAlgebra\Double\DenseVector.cs">
<Link>LinearAlgebra\Double\DenseVector.cs</Link>
</Compile>
<Compile Include="..\Numerics\LinearAlgebra\Double\Matrix.cs">
<Link>LinearAlgebra\Double\Matrix.cs</Link>
</Compile>
<Compile Include="..\Numerics\LinearAlgebra\Double\Vector.cs">
<Link>LinearAlgebra\Double\Vector.cs</Link>
</Compile>
<Compile Include="..\Numerics\NumberTheory\IntegerTheory.cs">
<Link>NumberTheory\IntegerTheory.cs</Link>
</Compile>
<Compile Include="..\Numerics\NumberTheory\IntegerTheory.Euclid.cs">
<Link>NumberTheory\IntegerTheory.Euclid.cs</Link>
</Compile>
<Compile Include="..\Numerics\Precision.cs">
<Link>Precision.cs</Link>
</Compile>
<Compile Include="..\Numerics\Random\AbstractRandomNumberGenerator.cs">
<Link>Random\AbstractRandomNumberGenerator.cs</Link>
</Compile>
<Compile Include="..\Numerics\Random\Mcg31m1.cs">
<Link>Random\Mcg31m1.cs</Link>
</Compile>
<Compile Include="..\Numerics\Random\Mcg59.cs">
<Link>Random\Mcg59.cs</Link>
</Compile>
<Compile Include="..\Numerics\Random\MersenneTwister.cs">
<Link>Random\MersenneTwister.cs</Link>
</Compile>
<Compile Include="..\Numerics\Random\Mrg32k3a.cs">
<Link>Random\Mrg32k3a.cs</Link>
</Compile>
<Compile Include="..\Numerics\Random\SystemCrypto.cs">
<Link>Random\SystemCrypto.cs</Link>
</Compile>
<Compile Include="..\Numerics\Random\SystemRandomExtensions.cs">
<Link>Random\SystemRandomExtensions.cs</Link>
</Compile>
<Compile Include="..\Numerics\Random\WH1982.cs">
<Link>Random\WH1982.cs</Link>
</Compile>
<Compile Include="..\Numerics\Random\WH2006.cs">
<Link>Random\WH2006.cs</Link>
</Compile>
<Compile Include="..\Numerics\Sampling\Sample.Chebyshev.cs">
<Link>Sampling\Sample.Chebyshev.cs</Link>
</Compile>
<Compile Include="..\Numerics\Sampling\Sample.Equidistant.cs">
<Link>Sampling\Sample.Equidistant.cs</Link>
</Compile>
<Compile Include="..\Numerics\Sampling\Sample.Random.cs">
<Link>Sampling\Sample.Random.cs</Link>
</Compile>
<Compile Include="..\Numerics\Sorting.cs">
<Link>Sorting.cs</Link>
</Compile>
<Compile Include="..\Numerics\SpecialFunctions.cs">
<Link>SpecialFunctions.cs</Link>
</Compile>
<Compile Include="..\Numerics\SpecialFunctions\Erf.cs">
<Link>SpecialFunctions\Erf.cs</Link>
</Compile>
<Compile Include="..\Numerics\SpecialFunctions\Factorial.cs">
<Link>SpecialFunctions\Factorial.cs</Link>
</Compile>
<Compile Include="..\Numerics\SpecialFunctions\Gamma.cs">
<Link>SpecialFunctions\Gamma.cs</Link>
</Compile>
<Compile Include="..\Numerics\SpecialFunctions\Stability.cs">
<Link>SpecialFunctions\Stability.cs</Link>
</Compile>
<Compile Include="..\Numerics\Statistics\Correlation.cs">
<Link>Statistics\Correlation.cs</Link>
</Compile>
<Compile Include="..\Numerics\Statistics\DescriptiveStatistics.cs">
<Link>Statistics\DescriptiveStatistics.cs</Link>
</Compile>
<Compile Include="..\Numerics\Statistics\Histogram.cs">
<Link>Statistics\Histogram.cs</Link>
</Compile>
<Compile Include="..\Numerics\Statistics\MCMC\MCMCSampler.cs">
<Link>Statistics\MCMC\MCMCSampler.cs</Link>
</Compile>
<Compile Include="..\Numerics\Statistics\MCMC\MetropolisHastingsSampler.cs">
<Link>Statistics\MCMC\MetropolisHastingsSampler.cs</Link>
</Compile>
<Compile Include="..\Numerics\Statistics\MCMC\MetropolisSampler.cs">
<Link>Statistics\MCMC\MetropolisSampler.cs</Link>
</Compile>
<Compile Include="..\Numerics\Statistics\MCMC\RejectionSampler.cs">
<Link>Statistics\MCMC\RejectionSampler.cs</Link>
</Compile>
<Compile Include="..\Numerics\Statistics\MCMC\UnivariateSliceSampler.cs">
<Link>Statistics\MCMC\UnivariateSliceSampler.cs</Link>
</Compile>
<Compile Include="..\Numerics\Statistics\Statistics.cs">
<Link>Statistics\Statistics.cs</Link>
</Compile>
<Compile Include="..\Numerics\Threading\AggregateException.cs">
<Link>Threading\AggregateException.cs</Link>
</Compile>
<Compile Include="..\Numerics\Threading\Parallel.cs">
<Link>Threading\Parallel.cs</Link>
</Compile>
<Compile Include="..\Numerics\Threading\Task.cs">
<Link>Threading\Task.cs</Link>
</Compile>
<Compile Include="..\Numerics\Threading\TaskOfT.cs">
<Link>Threading\TaskOfT.cs</Link>
</Compile>
<Compile Include="..\Numerics\Threading\ThreadQueue.cs">
<Link>Threading\ThreadQueue.cs</Link>
</Compile>
<Compile Include="..\Numerics\Trigonometry.cs">
<Link>Trigonometry.cs</Link>
</Compile>
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Properties\Resources.Designer.cs">
<DependentUpon>Resources.resx</DependentUpon>
<AutoGen>True</AutoGen>
<DesignTime>True</DesignTime>
</Compile>
</ItemGroup>
<ItemGroup>
<EmbeddedResource Include="Properties\Resources.resx">
<Generator>ResXFileCodeGenerator</Generator>
<LastGenOutput>Resources.Designer.cs</LastGenOutput>
</EmbeddedResource>
</ItemGroup>
<Import Project="$(MSBuildExtensionsPath32)\Microsoft\Silverlight\v3.0\Microsoft.Silverlight.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
<ProjectExtensions>
<VisualStudio>
<FlavorProperties GUID="{A1591282-1198-4647-A2B1-27E5FF5F6F3B}">
<SilverlightProjectProperties />
</FlavorProperties>
</VisualStudio>
</ProjectExtensions>
</Project>
Loading…
Cancel
Save