public static Either <TLeft, double> ParseToDouble <TLeft>(
this Either <TLeft, string> source,
IFormatProvider provider,
TLeft left)
{
return(source.FlatMap(x => DoubleParser.Parse <TLeft>(x, provider, left)));
}
protected internal override object CreateValue(IndexReader reader, object entryKey)
{
Entry entry = (Entry)entryKey;
System.String field = entry.field;
DoubleParser parser = (DoubleParser)entry.custom;
double[] retArray = new double[reader.MaxDoc()];
TermDocs termDocs = reader.TermDocs();
TermEnum termEnum = reader.Terms(new Term(field));
try
{
do
{
Term term = termEnum.Term();
if (term == null || (object)term.Field() != (object)field)
{
break;
}
double termval = parser.ParseDouble(term.Text());
termDocs.Seek(termEnum);
while (termDocs.Next())
{
retArray[termDocs.Doc()] = termval;
}
}while (termEnum.Next());
}
finally
{
termDocs.Close();
termEnum.Close();
}
return(retArray);
}
public static Either <TLeft, double> ParseToDouble <TLeft>(
this Either <TLeft, string> source,
NumberStyles style,
TLeft left)
{
return(source.FlatMap(x => DoubleParser.Parse <TLeft>(x, style, left)));
}
public void FeedForwardNeuralNetwork_LoadModelSparseMatrix()
{
var target = new FeedForwardNeuralNetwork <double>(
new[] { 2L, 3L, 2L });
var parser = new DoubleParser <string>();
var matrix = TestsHelper.ReadMatrix(
5,
5,
"[[-1.0, 1.0, 0.5, 0, 0], [1.0, -1.0, 0.5, 0, 0], [0, 0, 0, -1.0, 2.0], [0, 0, 0, 0.5, -1.5], [0, 0, 0, 1.0, -0.5]]",
(i, j) => new SparseDictionaryMatrix <double>(i, j, 0),
parser,
true);
var vector = TestsHelper.ReadVector(
5,
"[-1.0, 0.0, 1.0, -0.5, 0.5]",
new SparseDictionaryMathVectorFactory <double>(),
parser,
true);
var model = new NeuralNetworkModel <double, SparseDictionaryMatrix <double>, IMathVector <double> >(
matrix,
vector);
target.LoadModelSparse <SparseDictionaryMatrix <double>, ILongSparseMatrixLine <double>, IMathVector <double> >(
model);
this.AssertTargetFromMatrix(
model,
target);
}
private List<BreastCancerExample> ReadBreastCancerExamples()
{
var dataFile = GetDataPath("breast-cancer.txt");
// read the data programmatically into memory
var data = File.ReadAllLines(dataFile)
.Where(line => !string.IsNullOrEmpty(line) && !line.StartsWith("//"))
.Select(
line =>
{
var parts = line.Split('\t');
var ex = new BreastCancerExample
{
Features = new float[9]
};
var span = new ReadOnlySpan<char>(parts[0].ToCharArray());
DoubleParser.Parse(span, out ex.Label);
for (int j = 0; j < 9; j++)
{
span = new ReadOnlySpan<char>(parts[j + 1].ToCharArray());
DoubleParser.Parse(span, out ex.Features[j]);
}
return ex;
})
.ToList();
return data;
}
public static Either <TLeft, double> ParseToDouble <TLeft>(
this string source,
NumberStyles style,
IFormatProvider provider,
TLeft left)
{
return(DoubleParser.Parse <TLeft>(source, style, provider, left));
}
// ======================输出形参out 的基本使用==========================
static void Main6(string[] args)
{
double x = 0;
if (DoubleParser.TryParse("123", out x))
{
Console.WriteLine(x);// 123
}
}
public void RunTest_OneEquality()
{
var inputConstraintsMatrixText = "[[1,0,3],[0,2,2]]";
var inputConstraintsVectorText = "[4,12,18]";
var cost = new SimplexMaximumNumberField <double>(0, -18);
var nonBasicVariables = new[] { 0, 1 };
var basicVariables = new[] { 2, 3, 4 };
// Leitura da matriz das retrições.
var doubleElementsParser = new DoubleParser <string>();
var inputConstraintsMatrix = TestsHelper.ReadMatrix <double>(
3,
2,
inputConstraintsMatrixText,
(i, j) => new ArrayMathMatrix <double>(i, j),
doubleElementsParser,
true);
// Leitura do vector de restrições.
var vectorFactory = new ArrayVectorFactory <double>();
var inputConstraintsVector = TestsHelper.ReadVector <double>(
3,
inputConstraintsVectorText,
vectorFactory,
doubleElementsParser,
true);
// Introdução da função objectivo.
var inputObjectiveFunction = new ArrayMathVector <SimplexMaximumNumberField <double> >(2);
inputObjectiveFunction[0] = new SimplexMaximumNumberField <double>(
-3,
-3);
inputObjectiveFunction[1] = new SimplexMaximumNumberField <double>(
-5,
-2);
// Objecto de entrada para o algoritmo do simplex.
var simplexInput = new SimplexInput <double, SimplexMaximumNumberField <double> >(
basicVariables,
nonBasicVariables,
inputObjectiveFunction,
cost,
inputConstraintsMatrix,
inputConstraintsVector);
var doubleField = new DoubleField();
var target = new SimplexAlgorithm <double>(Comparer <double> .Default, doubleField);
var actual = target.Run(simplexInput);
// Verifica o custo
Assert.AreEqual(36, actual.Cost);
// Verifica a solução
Assert.AreEqual(2, actual.Solution[0]);
Assert.AreEqual(6, actual.Solution[1]);
}
public void RunSimplexTest_NoFeasibleSolution()
{
var inputConstraintsMatrixText = "[[0.3,0.5,0.6],[0.1,0.5,0.4],[0,0,-1]]";
var inputConstraintsVectorText = "[1.8,6,6]";
var cost = new SimplexMaximumNumberField <double>(0, -12);
var nonBasicVariables = new[] { 0, 1, 2 };
var basicVariables = new[] { 3, 4, 5 };
// Leitura da matriz das retrições.
var doubleElementsParser = new DoubleParser <string>();
var inputConstraintsMatrix = TestsHelper.ReadMatrix <double>(
3,
3,
inputConstraintsMatrixText,
(i, j) => new ArrayMathMatrix <double>(i, j),
doubleElementsParser,
true);
// Leitura do vector de restrições.
var vectorFactory = new ArrayVectorFactory <double>();
var inputConstraintsVector = TestsHelper.ReadVector <double>(
3,
inputConstraintsVectorText,
vectorFactory,
doubleElementsParser,
true);
// Introdução da função objectivo.
var inputObjectiveFunction = new ArrayMathVector <SimplexMaximumNumberField <double> >(3);
inputObjectiveFunction[0] = new SimplexMaximumNumberField <double>(
0.4,
-1.1);
inputObjectiveFunction[1] = new SimplexMaximumNumberField <double>(
0.5,
-0.9);
inputObjectiveFunction[2] = new SimplexMaximumNumberField <double>(
0,
1);
// Objecto de entrada para o algoritmo do simplex.
var simplexInput = new SimplexInput <double, SimplexMaximumNumberField <double> >(
basicVariables,
nonBasicVariables,
inputObjectiveFunction,
cost,
inputConstraintsMatrix,
inputConstraintsVector);
var doubleField = new DoubleField();
var target = new SimplexAlgorithm <double>(Comparer <double> .Default, doubleField);
var actual = target.Run(simplexInput);
// O problema tem uma solução cujo custo é inifito.
Assert.IsFalse(actual.HasSolution);
}
static void Main2()
{
double x = 0;
bool result = DoubleParser.TryParse("2", out x);
if (result)
{
Console.WriteLine(x);
}
}
/// <summary>
/// Constructor
/// </summary>
public BrushParser(XNamespace svgNamespace,
CssStyleCascade cssStyleCascade,
Dictionary <string, XElement> globalDefinitions,
DoubleParser doubleParser)
{
this.svgNamespace = svgNamespace;
this.cssStyleCascade = cssStyleCascade;
this.globalDefinitions = globalDefinitions;
this.doubleParser = doubleParser;
}
public SmartWatchDataParser(SmartWatchExcelData fileData, IDataRepository repository) : base(fileData)
{
_nameParser = new StringParser <SmartWatchColumnNames>(SmartWatchColumnNames.Name);
_priceParser = new PriceParser <SmartWatchColumnNames>(SmartWatchColumnNames.Price);
_descriptionParser = new StringParser <SmartWatchColumnNames>(SmartWatchColumnNames.Description);
_manufacturerParser = new ManufacturerParser <SmartWatchColumnNames>(SmartWatchColumnNames.Manufacturer, repository);
_connectionTypeParser = new ConnectionTypeParser <SmartWatchColumnNames>(SmartWatchColumnNames.InterfaceForConnecting, repository);
_screenDiagonalParser = new DoubleParser <SmartWatchColumnNames>(SmartWatchColumnNames.ScreenDiagonal);
_pulsometerParser = new BoolParser <SmartWatchColumnNames>(SmartWatchColumnNames.Pulsometer);
_simCardParser = new BoolParser <SmartWatchColumnNames>(SmartWatchColumnNames.SimCard);
}
/// <summary>
/// Constructor
/// </summary>
public TextParser(CssStyleCascade cssStyleCascade,
DoubleParser doubleParser,
BrushParser brushParser,
Clipping clipping)
: base(cssStyleCascade, doubleParser)
{
this.cssStyleCascade = cssStyleCascade;
this.doubleParser = doubleParser;
this.brushParser = brushParser;
this.clipping = clipping;
}
public ElectronicBookDataParser(ElectronicBookExcelData fileData, IDataRepository repository) : base(fileData)
{
_nameParser = new StringParser <ElectronicBookColumnNames>(ElectronicBookColumnNames.Name);
_priceParser = new PriceParser <ElectronicBookColumnNames>(ElectronicBookColumnNames.Price);
_descriptionParser = new StringParser <ElectronicBookColumnNames>(ElectronicBookColumnNames.Description);
_manufacturerParser = new ManufacturerParser <ElectronicBookColumnNames>(ElectronicBookColumnNames.Manufacturer, repository);
_screenDiagonalParser = new DoubleParser <ElectronicBookColumnNames>(ElectronicBookColumnNames.ScreenDiagonal);
_screenTypeParser = new ScreenTypeParser <ElectronicBookColumnNames>(ElectronicBookColumnNames.ScreenType, repository);
_batteryCapacityParser = new IntParser <ElectronicBookColumnNames>(ElectronicBookColumnNames.BatteryCapacity);
_workingTimeParser = new StringParser <ElectronicBookColumnNames>(ElectronicBookColumnNames.WorkingTime);
}
/// <summary>
/// This produces zero for an empty string.
/// </summary>
public bool TryParse(out Double value)
{
if (IsNA)
{
value = Double.NaN;
return(true);
}
var res = DoubleParser.Parse(out value, _outerBuffer, _ichMin, IchLim);
Contracts.Assert(res != DoubleParser.Result.Empty || value == 0);
return(res <= DoubleParser.Result.Empty);
}
/// <summary>
/// Get an attribute as double from the level (0 = top)
/// </summary>
public static double GetNumberPercentFromLevel(this CssStyleCascade cssStyleCascade, string name, int level, double defaultValue)
{
double retVal = defaultValue;
var strVal = cssStyleCascade.GetPropertyFromLevel(name, level);
if (!string.IsNullOrEmpty(strVal))
{
(_, retVal) = DoubleParser.GetNumberPercent(strVal);
}
return(retVal);
}
/// <summary>
/// Get an attribute as double from the cascade
/// </summary>
public static double GetNumber(this CssStyleCascade cssStyleCascade, string name, double defaultValue)
{
double retVal = defaultValue;
var strVal = cssStyleCascade.GetProperty(name);
if (!string.IsNullOrEmpty(strVal))
{
retVal = DoubleParser.GetNumber(strVal);
}
return(retVal);
}
public PhoneDataParser(PhoneExcelData fileData, IDataRepository repository) : base(fileData)
{
_nameParser = new StringParser <PhoneColumnNames>(PhoneColumnNames.Name);
_priceParser = new PriceParser <PhoneColumnNames>(PhoneColumnNames.Price);
_descriptionParser = new StringParser <PhoneColumnNames>(PhoneColumnNames.Description);
_manufacturerParser = new ManufacturerParser <PhoneColumnNames>(PhoneColumnNames.Manufacturer, repository);
_ramParser = new IntParser <PhoneColumnNames>(PhoneColumnNames.RAM);
_romParser = new IntParser <PhoneColumnNames>(PhoneColumnNames.ROM);
_cpuParser = new StringParser <PhoneColumnNames>(PhoneColumnNames.CPU);
_batteryCapacityParser = new IntParser <PhoneColumnNames>(PhoneColumnNames.BatteryCapacity);
_screenDiagonalParser = new DoubleParser <PhoneColumnNames>(PhoneColumnNames.ScreenDiagonal);
_cameraParser = new DoubleParser <PhoneColumnNames>(PhoneColumnNames.Camera);
}
static FieldCache_Fields()
{
DEFAULT = new FieldCacheImpl();
DEFAULT_BYTE_PARSER = new AnonymousClassByteParser();
DEFAULT_SHORT_PARSER = new AnonymousClassShortParser();
DEFAULT_INT_PARSER = new AnonymousClassIntParser();
DEFAULT_FLOAT_PARSER = new AnonymousClassFloatParser();
DEFAULT_LONG_PARSER = new AnonymousClassLongParser();
DEFAULT_DOUBLE_PARSER = new AnonymousClassDoubleParser();
NUMERIC_UTILS_INT_PARSER = new AnonymousClassIntParser1();
NUMERIC_UTILS_FLOAT_PARSER = new AnonymousClassFloatParser1();
NUMERIC_UTILS_LONG_PARSER = new AnonymousClassLongParser1();
NUMERIC_UTILS_DOUBLE_PARSER = new AnonymousClassDoubleParser1();
}
public void BasicDoubleParserTest()
{
var parser = new DoubleParser();
Assert.Equal(1.234, parser.Parse("1.234"));
Assert.Equal(1.234, parser.Parse("1,234"));
Assert.Equal(1234.0, parser.Parse("1234"));
Assert.Equal(123.45, parser.Parse("123,45"));
Assert.Equal(1234.56, parser.Parse("1.234,56"));
Assert.Equal(1234.56, parser.Parse("1,234.56"));
Assert.Equal(0.0, parser.ParseOrFallback("0", default));
Assert.Equal(-123.45, parser.Parse("-123.45"));
Assert.Equal(-123.45, parser.Parse("-123,45"));
Assert.Equal(-1234.5, parser.Parse("-1,234.5"));
Assert.Equal(-1234.5, parser.Parse("-1.234,5"));
}
public void Apply(IntermediateColumn[] columns)
{
foreach (var col in columns)
{
if (!col.RawData.Skip(1)
.All(x =>
{
Single value;
return(Conversions.Instance.TryParse(in x, out value));
})
)
{
continue;
}
col.SuggestedType = NumberType.R4;
Single first;
col.HasHeader = !DoubleParser.TryParse(col.RawData[0].Span, out first);
}
}
/// <summary>
/// Parse an SVG given as XElement root
/// </summary>
public GraphicVisual ParseRoot(XElement root)
{
var nameSpaceAttributes = root.Attributes().Where(a => a.IsNamespaceDeclaration);
var defaultNamespaceAttribute = root.Attributes().Where(a => a.IsNamespaceDeclaration && a.Name.Namespace == XNamespace.None).FirstOrDefault();
XNamespace defaultNamespace = defaultNamespaceAttribute.Value;
Matrix currentTransformationMatrix = Matrix.Identity;
cssStyleCascade = new CssStyleCascade(root);
var svgViewBox = new SvgViewBox
{
ViewBox = new Rect(0, 0, 100, 100),
Align = "none",
Slice = "meet"
};
cssStyleCascade.PushViewBox(svgViewBox);
doubleParser = new DoubleParser(cssStyleCascade);
ReadGlobalDefinitions(root);
var brushParser = new BrushParser(defaultNamespace, cssStyleCascade, globalDefinitions, doubleParser);
var geometryParser = new GeometryParser(doubleParser);
var geometryTextParser = new GeometryTextParser(cssStyleCascade, doubleParser);
clipping = new Clipping(cssStyleCascade, globalDefinitions, geometryParser, geometryTextParser);
shapeParser = new ShapeParser(cssStyleCascade, brushParser, geometryParser, clipping);
textParser = new TextParser(cssStyleCascade, doubleParser, brushParser, clipping);
GraphicVisual visual = ParseSVG(root, currentTransformationMatrix, true);
visual = OptimizeVisual.Optimize(visual);
return(visual);
}
static void Main(string[] args)
{
var reverser = new NumberReverser();
Console.WriteLine("Enter the number");
var userString = Console.ReadLine();
if (DoubleParser.TryParse(userString, out double parsedDouble))
{
reverser.Reverse(ref parsedDouble);
Console.WriteLine(parsedDouble);
}
else if (int.TryParse(userString, out int parsedInt))
{
reverser.Reverse(ref parsedInt);
Console.WriteLine(parsedInt);
}
else
{
BugReport("Input is not a number");
}
Console.ReadKey();
}
public static Maybe <double> ParseToDouble(this string source)
{
return(DoubleParser.Parse(source));
}
internal DoubleComparator(int numHits, System.String field, Lucene.Net.Search.Parser parser)
{
values = new double[numHits];
this.field = field;
this.parser = (DoubleParser) parser;
}
internal DoubleComparator(int numHits, System.String field, Lucene.Net.Search.Parser parser)
{
values = new double[numHits];
this.field = field;
this.parser = (DoubleParser)parser;
}
static FieldCache_Fields()
{
DEFAULT = new FieldCacheImpl();
DEFAULT_BYTE_PARSER = new AnonymousClassByteParser();
DEFAULT_SHORT_PARSER = new AnonymousClassShortParser();
DEFAULT_INT_PARSER = new AnonymousClassIntParser();
DEFAULT_FLOAT_PARSER = new AnonymousClassFloatParser();
DEFAULT_LONG_PARSER = new AnonymousClassLongParser();
DEFAULT_DOUBLE_PARSER = new AnonymousClassDoubleParser();
NUMERIC_UTILS_INT_PARSER = new AnonymousClassIntParser1();
NUMERIC_UTILS_FLOAT_PARSER = new AnonymousClassFloatParser1();
NUMERIC_UTILS_LONG_PARSER = new AnonymousClassLongParser1();
NUMERIC_UTILS_DOUBLE_PARSER = new AnonymousClassDoubleParser1();
}
static ExtendedFieldCacheImpl()
{
LONG_PARSER = new AnonymousClassLongParser();
DOUBLE_PARSER = new AnonymousClassDoubleParser();
}
// inherit javadocs
public virtual double[] GetDoubles(IndexReader reader, System.String field, DoubleParser parser)
{
return (double[]) doublesCache.Get(reader, new Entry(field, parser));
}
static ExtendedFieldCacheImpl()
{
LONG_PARSER = new AnonymousClassLongParser();
DOUBLE_PARSER = new AnonymousClassDoubleParser();
}
// inherit javadocs
public virtual double[] GetDoubles(IndexReader reader, System.String field, DoubleParser parser)
{
return((double[])doublesCache.Get(reader, new Entry(field, parser)));
}
public static Maybe <double> ParseToDouble(this Maybe <string> source, NumberStyles style, IFormatProvider provider)
{
return(source.FlatMap(x => DoubleParser.Parse(x, style, provider)));
}
/// <summary>
/// Minimize a function using the supplied termination criterion
/// </summary>
/// <param name="function">The function to minimize</param>
/// <param name="initial">The initial point</param>
/// <param name="term">termination criterion to use</param>
/// <param name="result">The point at the optimum</param>
/// <param name="optimum">The optimum function value</param>
/// <exception cref="PrematureConvergenceException">Thrown if successive points are within numeric precision of each other, but termination condition is still unsatisfied.</exception>
public void Minimize(DifferentiableFunction function, ref VBuffer <Float> initial, ITerminationCriterion term, ref VBuffer <Float> result, out Float optimum)
{
const string computationName = "LBFGS Optimizer";
using (var pch = Env.StartProgressChannel(computationName))
using (var ch = Env.Start(computationName))
{
ch.Info("Beginning optimization");
ch.Info("num vars: {0}", initial.Length);
ch.Info("improvement criterion: {0}", term.FriendlyName);
OptimizerState state = MakeState(ch, pch, function, ref initial);
term.Reset();
var header = new ProgressHeader(new[] { "Loss", "Improvement" }, new[] { "iterations", "gradients" });
pch.SetHeader(header,
(Action <IProgressEntry>)(e =>
{
e.SetProgress(0, (double)(state.Iter - 1));
e.SetProgress(1, state.GradientCalculations);
}));
bool finished = false;
pch.Checkpoint(state.Value, null, 0);
state.UpdateDir();
while (!finished)
{
bool success = state.LineSearch(ch, false);
if (!success)
{
// problem may be numerical errors in previous gradients
// try to save state of optimization by discarding them
// and starting over with gradient descent.
state.DiscardOldVectors();
state.UpdateDir();
state.LineSearch(ch, true);
}
string message;
finished = term.Terminate(state, out message);
double?improvement = null;
double x;
int end;
if (message != null && DoubleParser.TryParse(out x, message, 0, message.Length, out end))
{
improvement = x;
}
pch.Checkpoint(state.Value, improvement, state.Iter);
if (!finished)
{
state.Shift();
state.UpdateDir();
}
}
state.X.CopyTo(ref result);
optimum = state.Value;
ch.Done();
}
}
/// <summary>
/// Constructor
/// </summary>
public GeometryParser(DoubleParser doubleParser)
{
this.doubleParser = doubleParser;
}
