From 1cf455eddc20395a6cdfe451adf80b84fb089bea Mon Sep 17 00:00:00 2001 From: Marcus Cuda Date: Sun, 29 Nov 2009 14:37:35 +0800 Subject: [PATCH] add silverlight project --- src/.gitignore | 1 + src/MathNet.Numerics.sln | 6 + src/Numerics/Complex.cs | 10 +- src/Numerics/Complex32.cs | 8 +- src/Numerics/GlobalizationHelper.cs | 69 +++ src/Numerics/LinearAlgebra/Double/Matrix.cs | 15 +- src/Numerics/LinearAlgebra/Double/Vector.cs | 15 +- src/Numerics/Numerics.csproj | 2 +- src/Numerics/Precision.cs | 77 +++ src/Numerics/Statistics/Histogram.cs | 36 +- src/Numerics/Threading/AggregateException.cs | 2 + src/Silverlight/Properties/AssemblyInfo.cs | 49 ++ .../Properties/Resources.Designer.cs | 576 ++++++++++++++++++ src/Silverlight/Properties/Resources.resx | 291 +++++++++ src/Silverlight/Silverlight.csproj | 350 +++++++++++ 15 files changed, 1489 insertions(+), 18 deletions(-) create mode 100644 src/Silverlight/Properties/AssemblyInfo.cs create mode 100644 src/Silverlight/Properties/Resources.Designer.cs create mode 100644 src/Silverlight/Properties/Resources.resx create mode 100644 src/Silverlight/Silverlight.csproj diff --git a/src/.gitignore b/src/.gitignore index bf1a3933..becc3258 100644 --- a/src/.gitignore +++ b/src/.gitignore @@ -1,3 +1,4 @@ +Bin bin obj *.user diff --git a/src/MathNet.Numerics.sln b/src/MathNet.Numerics.sln index f22f09ff..bce422eb 100644 --- a/src/MathNet.Numerics.sln +++ b/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 diff --git a/src/Numerics/Complex.cs b/src/Numerics/Complex.cs index 51d3a9b1..4cab271a 100644 --- a/src/Numerics/Complex.cs +++ b/src/Numerics/Complex.cs @@ -67,7 +67,9 @@ namespace MathNet.Numerics /// Wikipedia /// /// +#if !SILVERLIGHT [Serializable] +#endif [StructLayout(LayoutKind.Sequential)] public struct Complex : IFormattable, IEquatable, IPrecisionSupport { @@ -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 diff --git a/src/Numerics/Complex32.cs b/src/Numerics/Complex32.cs index 0afdb618..076cc641 100644 --- a/src/Numerics/Complex32.cs +++ b/src/Numerics/Complex32.cs @@ -67,7 +67,9 @@ namespace MathNet.Numerics /// Wikipedia /// /// +#if !SILVERLIGHT [Serializable] +#endif [StructLayout(LayoutKind.Sequential)] public struct Complex32 : IFormattable, IEquatable, IPrecisionSupport { @@ -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 diff --git a/src/Numerics/GlobalizationHelper.cs b/src/Numerics/GlobalizationHelper.cs index 3f01362c..cf2dfd00 100644 --- a/src/Numerics/GlobalizationHelper.cs +++ b/src/Numerics/GlobalizationHelper.cs @@ -125,6 +125,74 @@ namespace MathNet.Numerics } } +#if SILVERLIGHT + /// + /// Globalized Parsing: Parse a double number + /// + /// First token of the number. + /// The parsed double number using the current culture information. + /// + internal static double ParseDouble(ref LinkedListNode 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; + } + + /// + /// Globalized Parsing: Parse a float number + /// + /// First token of the number. + /// The parsed float number using the current culture information. + /// + internal static float ParseSingle(ref LinkedListNode 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 /// /// Globalized Parsing: Parse a double number /// @@ -192,5 +260,6 @@ namespace MathNet.Numerics token = token.Next; return value; } +#endif } } \ No newline at end of file diff --git a/src/Numerics/LinearAlgebra/Double/Matrix.cs b/src/Numerics/LinearAlgebra/Double/Matrix.cs index 1ba95145..c5226e2b 100644 --- a/src/Numerics/LinearAlgebra/Double/Matrix.cs +++ b/src/Numerics/LinearAlgebra/Double/Matrix.cs @@ -36,8 +36,15 @@ namespace MathNet.Numerics.LinearAlgebra.Double /// /// Defines the base class for Matrix classes. /// +#if !SILVERLIGHT [Serializable] - public abstract class Matrix : IFormattable, ICloneable, IEquatable +#endif + public abstract class Matrix : +#if SILVERLIGHT + IFormattable, IEquatable +#else + IFormattable, IEquatable, ICloneable +#endif { /// /// Initializes a new instance of the class. @@ -237,6 +244,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double #region Implemented Interfaces +#if !SILVERLIGHT #region ICloneable /// @@ -251,6 +259,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double } #endregion +#endif #region IEquatable @@ -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); diff --git a/src/Numerics/LinearAlgebra/Double/Vector.cs b/src/Numerics/LinearAlgebra/Double/Vector.cs index a90cfa26..81a56357 100644 --- a/src/Numerics/LinearAlgebra/Double/Vector.cs +++ b/src/Numerics/LinearAlgebra/Double/Vector.cs @@ -39,8 +39,15 @@ namespace MathNet.Numerics.LinearAlgebra.Double /// /// Defines the base class for Vector classes. /// +#if !SILVERLIGHT [Serializable] - public abstract class Vector : IFormattable, IEnumerable, ICloneable, IEquatable +#endif + public abstract class Vector : +#if SILVERLIGHT + IFormattable, IEnumerable, IEquatable +#else + IFormattable, IEnumerable, IEquatable, ICloneable +#endif { /// /// Initializes a new instance of the class. @@ -781,6 +788,7 @@ namespace MathNet.Numerics.LinearAlgebra.Double #region Implemented Interfaces +#if !SILVERLIGHT #region ICloneable /// @@ -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); diff --git a/src/Numerics/Numerics.csproj b/src/Numerics/Numerics.csproj index 1a794c97..7e37402c 100644 --- a/src/Numerics/Numerics.csproj +++ b/src/Numerics/Numerics.csproj @@ -20,7 +20,7 @@ full false bin\Debug\ - DEBUG;TRACE + TRACE;DEBUG prompt 4 diff --git a/src/Numerics/Precision.cs b/src/Numerics/Precision.cs index 7af2db1d..d0761a2e 100644 --- a/src/Numerics/Precision.cs +++ b/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 } /// @@ -214,7 +222,11 @@ namespace MathNet.Numerics /// private static long GetLongFromDouble(double value) { +#if SILVERLIGHT + return DoubleToInt64Bits(value); +#else return BitConverter.DoubleToInt64Bits(value); +#endif } /// @@ -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 } /// @@ -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 } /// @@ -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 } /// @@ -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 } } \ No newline at end of file diff --git a/src/Numerics/Statistics/Histogram.cs b/src/Numerics/Statistics/Histogram.cs index c58e66c1..e0b1d648 100644 --- a/src/Numerics/Statistics/Histogram.cs +++ b/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; /// /// A consists of a series of s, /// each representing a region limited by a lower bound (exclusive) and an upper bound (inclusive). /// +#if !SILVERLIGHT [Serializable] - public class Bucket : IComparable, ICloneable +#endif + public class Bucket : +#if SILVERLIGHT + IComparable +#else + IComparable, ICloneable +#endif { /// /// This IComparer 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(); /// /// 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. /// /// A cloned Bucket object. - public Object Clone() + public object Clone() { return new Bucket(LowerBound, UpperBound, Count); } @@ -159,7 +166,7 @@ namespace MathNet.Numerics.Statistics /// 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 /// /// A class which computes histograms of data. /// +#if !SILVERLIGHT [Serializable] +#endif public class Histogram { /// /// Contains all the Buckets of the Histogram. /// - List buckets; + private List buckets; /// /// Indicates whether the elements of buckets are currently sorted. /// - bool areBucketsSorted; + private bool areBucketsSorted; /// /// 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()); } diff --git a/src/Numerics/Threading/AggregateException.cs b/src/Numerics/Threading/AggregateException.cs index 0b4d09e3..b376f19f 100644 --- a/src/Numerics/Threading/AggregateException.cs +++ b/src/Numerics/Threading/AggregateException.cs @@ -35,7 +35,9 @@ namespace MathNet.Numerics.Threading /// /// Represents multiple errors that occur during application execution. /// +#if !SILVERLIGHT [Serializable] +#endif public class AggregateException : Exception { /// diff --git a/src/Silverlight/Properties/AssemblyInfo.cs b/src/Silverlight/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..7957617c --- /dev/null +++ b/src/Silverlight/Properties/AssemblyInfo.cs @@ -0,0 +1,49 @@ +// +// 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; +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")] diff --git a/src/Silverlight/Properties/Resources.Designer.cs b/src/Silverlight/Properties/Resources.Designer.cs new file mode 100644 index 00000000..1a252cba --- /dev/null +++ b/src/Silverlight/Properties/Resources.Designer.cs @@ -0,0 +1,576 @@ +//------------------------------------------------------------------------------ +// +// 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. +// +//------------------------------------------------------------------------------ + +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", "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() { + } + + /// + /// 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 argument must be between 0 and 1.. + /// + internal static string ArgumentBetween0And1 { + get { + return ResourceManager.GetString("ArgumentBetween0And1", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Value cannot be in the range -1 < x < 1.. + /// + internal static string ArgumentCannotBeBetweenOneAndNegativeOne { + get { + return ResourceManager.GetString("ArgumentCannotBeBetweenOneAndNegativeOne", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Value must be even.. + /// + internal static string ArgumentEven { + get { + return ResourceManager.GetString("ArgumentEven", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The histogram does not contains the value.. + /// + 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 At least one item of {0} is a null reference (Nothing in Visual Basic).. + /// + internal static string ArgumentItemNull { + get { + return ResourceManager.GetString("ArgumentItemNull", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Value must be greater than or equal to one.. + /// + internal static string ArgumentLessThanOne { + get { + return ResourceManager.GetString("ArgumentLessThanOne", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to han the given upper bound.. + /// + internal static string ArgumentLowerBoundLargerThanUpperBound { + get { + return ResourceManager.GetString("ArgumentLowerBoundLargerThanUpperBound", 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 In the specified range, the minimum is greater than maximum.. + /// + internal static string ArgumentMinValueGreaterThanMaxValue { + get { + return ResourceManager.GetString("ArgumentMinValueGreaterThanMaxValue", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Value must be positive.. + /// + internal static string ArgumentMustBePositive { + get { + return ResourceManager.GetString("ArgumentMustBePositive", 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 Value must be odd.. + /// + internal static string ArgumentOdd { + get { + return ResourceManager.GetString("ArgumentOdd", 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 ArgumentVectorsSameLength { + get { + return ResourceManager.GetString("ArgumentVectorsSameLength", 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 The supplied collection is empty.. + /// + internal static string CollectionEmpty { + get { + return ResourceManager.GetString("CollectionEmpty", 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 parameterization for the distribution.. + /// + internal static string InvalidDistributionParameters { + get { + return ResourceManager.GetString("InvalidDistributionParameters", 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 The number of columns of a matrix must be positive.. + /// + internal static string MatrixColumnsMustBePositive { + get { + return ResourceManager.GetString("MatrixColumnsMustBePositive", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The number of rows of a matrix must be positive.. + /// + internal static string MatrixRowsMustBePositive { + get { + return ResourceManager.GetString("MatrixRowsMustBePositive", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The number of rows or columns of a matrix must be positive.. + /// + internal static string MatrixRowsOrColumnsMustBePositive { + get { + return ResourceManager.GetString("MatrixRowsOrColumnsMustBePositive", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The two arguments can't be compared (maybe they are part of a partial ordering?). + /// + internal static string PartialOrderException { + get { + return ResourceManager.GetString("PartialOrderException", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The sampler's proposal distribution is not upper bounding the target density.. + /// + internal static string ProposalDistributionNoUpperBound { + get { + return ResourceManager.GetString("ProposalDistributionNoUpperBound", 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); + } + } + + /// + /// Looks up a localized string similar to A user defined provider has not been specified.. + /// + internal static string UserDefinedProviderNotSpecified { + get { + return ResourceManager.GetString("UserDefinedProviderNotSpecified", resourceCulture); + } + } + } +} diff --git a/src/Silverlight/Properties/Resources.resx b/src/Silverlight/Properties/Resources.resx new file mode 100644 index 00000000..f8f60969 --- /dev/null +++ b/src/Silverlight/Properties/Resources.resx @@ -0,0 +1,291 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 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. + + + 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). + + + Invalid parameterization for the distribution. + + + Value must be even. + + + Value must be odd. + + + At least one item of {0} is a null reference (Nothing in Visual Basic). + + + The supplied collection is empty. + + + Value cannot be in the range -1 < x < 1. + + + Value must be greater than or equal to one. + + + Value must be positive. + + + A user defined provider has not been specified. + + + In the specified range, the minimum is greater than maximum. + + + han the given upper bound. + + + The two arguments can't be compared (maybe they are part of a partial ordering?) + + + The number of columns of a matrix must be positive. + + + The number of rows of a matrix must be positive. + + + The number of rows or columns of a matrix must be positive. + + + The argument must be between 0 and 1. + + + The sampler's proposal distribution is not upper bounding the target density. + + \ No newline at end of file diff --git a/src/Silverlight/Silverlight.csproj b/src/Silverlight/Silverlight.csproj new file mode 100644 index 00000000..058727a5 --- /dev/null +++ b/src/Silverlight/Silverlight.csproj @@ -0,0 +1,350 @@ + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {0CCA2BA4-9DF2-4E9B-8A77-0A1F61A96A77} + {A1591282-1198-4647-A2B1-27E5FF5F6F3B};{fae04ec0-301f-11d3-bf4b-00c04f79efbc} + Library + Properties + MathNet.Numerics + MathNet.Numerics.Silverlight + v3.5 + false + true + true + + + true + full + false + Bin\Debug + DEBUG;TRACE;SILVERLIGHT + true + true + prompt + 4 + + + pdbonly + true + Bin\Release + TRACE;SILVERLIGHT + true + true + prompt + 4 + + + + + + + + + + + + + Algorithms\ILinearAlgebraProvider.cs + + + Algorithms\ILinearAlgebraProviderOfT.cs + + + Algorithms\ManagedLinearAlgebraProvider.cs + + + Combinatorics.cs + + + Complex.cs + + + Complex32.cs + + + Constants.cs + + + Control.cs + + + Distributions\Continuous\Beta.cs + + + Distributions\Continuous\ContinuousUniform.cs + + + Distributions\Continuous\Gamma.cs + + + Distributions\Continuous\LogNormal.cs + + + Distributions\Continuous\Normal.cs + + + Distributions\Continuous\Weibull.cs + + + Distributions\Discrete\Bernoulli.cs + + + Distributions\Discrete\Binomial.cs + + + Distributions\Discrete\Categorical.cs + + + Distributions\Discrete\DiscreteUniform.cs + + + Distributions\IContinuousDistribution.cs + + + Distributions\IDiscreteDistribution.cs + + + Distributions\IDistribution.cs + + + Distributions\Multivariate\Dirichlet.cs + + + Distributions\Multivariate\Multinomial.cs + + + GlobalizationHelper.cs + + + IntegralTransforms\Algorithms\DiscreteFourierTransform.Bluestein.cs + + + IntegralTransforms\Algorithms\DiscreteFourierTransform.Naive.cs + + + IntegralTransforms\Algorithms\DiscreteFourierTransform.Options.cs + + + IntegralTransforms\Algorithms\DiscreteFourierTransform.RadixN.cs + + + IntegralTransforms\Algorithms\DiscreteHartleyTransform.Naive.cs + + + IntegralTransforms\Algorithms\DiscreteHartleyTransform.Options.cs + + + IntegralTransforms\FourierOptions.cs + + + IntegralTransforms\HartleyOptions.cs + + + IntegralTransforms\Transform.cs + + + Integration\Algorithms\DoubleExponentialTransformation.cs + + + Integration\Algorithms\NewtonCotesTrapeziumRule.cs + + + Integration\Algorithms\SimpsonRule.cs + + + Integration\Integrate.cs + + + Interpolation\Algorithms\AkimaSplineInterpolation.cs + + + Interpolation\Algorithms\BarycentricInterpolation.cs + + + Interpolation\Algorithms\BulirschStoerRationalInterpolation.cs + + + Interpolation\Algorithms\CubicHermiteSplineInterpolation.cs + + + Interpolation\Algorithms\CubicSplineInterpolation.cs + + + Interpolation\Algorithms\EquidistantPolynomialInterpolation.cs + + + Interpolation\Algorithms\FloaterHormannRationalInterpolation.cs + + + Interpolation\Algorithms\LinearSplineInterpolation.cs + + + Interpolation\Algorithms\NevillePolynomialInterpolation.cs + + + Interpolation\Algorithms\SplineInterpolation.cs + + + Interpolation\IInterpolation.cs + + + Interpolation\Interpolate.cs + + + Interpolation\SplineBoundaryCondition.cs + + + IPrecisionSupport.cs + + + LinearAlgebra\Double\DenseMatrix.cs + + + LinearAlgebra\Double\DenseVector.cs + + + LinearAlgebra\Double\Matrix.cs + + + LinearAlgebra\Double\Vector.cs + + + NumberTheory\IntegerTheory.cs + + + NumberTheory\IntegerTheory.Euclid.cs + + + Precision.cs + + + Random\AbstractRandomNumberGenerator.cs + + + Random\Mcg31m1.cs + + + Random\Mcg59.cs + + + Random\MersenneTwister.cs + + + Random\Mrg32k3a.cs + + + Random\SystemCrypto.cs + + + Random\SystemRandomExtensions.cs + + + Random\WH1982.cs + + + Random\WH2006.cs + + + Sampling\Sample.Chebyshev.cs + + + Sampling\Sample.Equidistant.cs + + + Sampling\Sample.Random.cs + + + Sorting.cs + + + SpecialFunctions.cs + + + SpecialFunctions\Erf.cs + + + SpecialFunctions\Factorial.cs + + + SpecialFunctions\Gamma.cs + + + SpecialFunctions\Stability.cs + + + Statistics\Correlation.cs + + + Statistics\DescriptiveStatistics.cs + + + Statistics\Histogram.cs + + + Statistics\MCMC\MCMCSampler.cs + + + Statistics\MCMC\MetropolisHastingsSampler.cs + + + Statistics\MCMC\MetropolisSampler.cs + + + Statistics\MCMC\RejectionSampler.cs + + + Statistics\MCMC\UnivariateSliceSampler.cs + + + Statistics\Statistics.cs + + + Threading\AggregateException.cs + + + Threading\Parallel.cs + + + Threading\Task.cs + + + Threading\TaskOfT.cs + + + Threading\ThreadQueue.cs + + + Trigonometry.cs + + + + Resources.resx + True + True + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + + + + + + + + + + \ No newline at end of file