public MControler(IVisualizator visualizator, INumberParser converter, IInnerDataValidator innerDataParser, string [] arr)
{
_visualizator = visualizator;
_parser = converter;
_innerDataValidator = innerDataParser;
_arr = arr;
}
// Attempts to parse a number from the beginning of the given input string. Returns the character size of the matched string.
static (double, int) GetNextNumber(string input, INumberParser numberParser)
{
// Attempt to parse anything before an operator or space as a number
Regex regex = new Regex("^-?([^-+/*\\(\\)\\^\\s]+)");
var match = regex.Match(input);
if (match.Success)
{
// Might be a number
var matchLength = match.Groups[0].Length;
var parsedNum = ApiInformation.IsTypePresent(numberParser?.GetType().FullName)
? numberParser.ParseDouble(input.Substring(0, matchLength))
: double.TryParse(input.Substring(0, matchLength), out var d)
? (double?)d
: null;
if (parsedNum != null)
{
// Parsing was successful
return(parsedNum.Value, matchLength);
}
}
return(double.NaN, 0);
}
public MarketSeriesPatternPreparer(string filename, INumberParser parser, int seriesLength = 5, int forecastLength = 3, int priceShift = -10000)
{
_parser = parser;
_seriesLength = seriesLength;
_forecastLength = forecastLength;
_priceShift = priceShift;
_patterns = Load(filename);
}
public UniversalDecoratedNumberParser(INumberParser numberParser)
{
_parsers = new List <BaseDecoratedNumberParser>
{
new BracketDecoratedNumberParser(numberParser),
new UndecoratedAndDelimiterDecoratedNumberParser(numberParser),
};
}
public Calculator(
INumberNamer numberNamer,
INumberParser numberParser,
IOperatorParser operatorParser)
{
_numberNamer = numberNamer;
_numberParser = numberParser;
_operatorParser = operatorParser;
}
public void ManuallyCreateSubstitutes()
{
// create both subs
factory = Substitute.For <INumberParserFactory>();
parser = Substitute.For <INumberParser>();
// now set up both separately
factory.Create(',').Returns(parser);
parser.Parse("an expression").Returns(new[] { 1, 2, 3 });
Assert.AreEqual(
factory.Create(',').Parse("an expression"),
new[] { 1, 2, 3 });
}
public List <string> GenerateResultsBetween(int rangeStart, int rangeEnd)
{
var resultSet = new List <string>();
var inputRange = Enumerable.Range(rangeStart, rangeEnd).ToList();
inputRange.ForEach(i =>
{
INumberParser numberParser
= Parsers
.First(p => i % p.Divisor == 0);
resultSet.Add(numberParser.Parse(i));
});
return(resultSet);
}
public static double?Compute(string expr, INumberParser numberParser)
{
// Tokenize the input string
var tokens = GetTokens(expr, numberParser);
if (tokens.Count > 0)
{
// Rearrange to postfix notation
var postfixTokens = ConvertInfixToPostfix(tokens);
if (postfixTokens.Count > 0)
{
// Compute expression
return(ComputePostfixExpression(postfixTokens));
}
}
return(null);
}
// Attempts to parse a number from the beginning of the given input string. Returns the character size of the matched string.
private static Tuple <double, int> GetNextNumber(string input, INumberParser numberParser)
{
// Attempt to parse anything before an operator or space as a number
string regex = "^-?([^-+/*\\(\\)\\^\\s]+)";
Match match = Regex.Match(input, regex);
if (match.Success)
{
// Might be a number
var parsedNum = numberParser.ParseDouble(match.Value);
if (parsedNum.HasValue)
{
// Parsing was successful
return(new Tuple <double, int>(parsedNum.Value, match.Length));
}
}
return(new Tuple <double, int>(double.NaN, 0));
}
public BmiCalculator(ICsvRowParser csvParser, INumberParser numberParser)
{
this.numberParser = numberParser;
this.csvParser = csvParser;
}
public UndecoratedAndDelimiterDecoratedNumberParser(INumberParser numberParser) : base(numberParser)
{
}
// Returns list of MathTokens from expression input string. If there are any parsing errors, it returns an empty vector.
private static List <MathToken> GetTokens(string input, INumberParser numberParser)
{
var tokens = new List <MathToken>();
var expectNumber = true;
while (input.Length > 0)
{
// Skip spaces
var nextChar = input[0];
if (nextChar != ' ')
{
if (expectNumber)
{
if (nextChar == '(')
{
// Open parens are also acceptable, but don't change the next expected token type.
tokens.Add(new MathToken(MathTokenType.Parenthesis, nextChar));
}
else
{
var(value, charLength) = GetNextNumber(input, numberParser);
if (charLength > 0)
{
tokens.Add(new MathToken(MathTokenType.Numeric, value));
// UNO TODO: Was pointer manipulation, may be better off with Span<char>.
input = input.Substring(charLength - 1); // advance the end of the token
expectNumber = false; // next token should be an operator
}
else
{
// Error case -- next token is not a number
return(new List <MathToken>());
}
}
}
else
{
if (c_numberBoxOperators.IndexOf(nextChar) != -1)
{
tokens.Add(new MathToken(MathTokenType.Operator, nextChar));
expectNumber = true; // next token should be a number
}
else if (nextChar == ')')
{
// Closed parens are also acceptable, but don't change the next expected token type.
tokens.Add(new MathToken(MathTokenType.Parenthesis, nextChar));
}
else
{
// Error case -- could not evaluate part of the expression
return(new List <MathToken>());
}
}
}
// UNO TODO: Was pointer manipulation, may be better off with Span<char>.
input = input.Substring(1);
}
return(tokens);
}
public TestPatternPreparer(string filename, INumberParser parser)
{
_parser = parser;
_patterns = Load(filename);
}
public PriceParser(INumberParser numberParser)
{
_numberParser = numberParser;
}
public StringCalculator2(ITokenizer tokenizer, INegativeChecker checker, INumberParser parser)
{
_tokenizer = tokenizer;
_checker = checker;
_parser = parser;
}
public BracketDecoratedNumberParser(INumberParser numberParser) : base(numberParser)
{
}
public ReadWordInterrupt(INumberParser numberParser)
{
this.numberParser = numberParser;
}
public StringCalculator(INumberParser numberParser, IAdder adder)
{
_numberParser = numberParser;
_adder = adder;
}
private static List <MathToken> GetTokens(string input, INumberParser numberParser)
{
var tokens = new List <MathToken>();
bool expectNumber = true;
int i = 0;
while (i < input.Length)
{
// Skip spaces
var nextChar = input[i];
if (nextChar != ' ')
{
if (expectNumber)
{
if (nextChar == '(')
{
// Open parens are also acceptable, but don't change the next expected token type.
tokens.Add(new MathToken(MathTokenType.Parenthesis, nextChar));
}
else
{
var result = GetNextNumber(input.Substring(i), numberParser);
var value = result.Item1;
var charLength = result.Item2;
if (charLength > 0)
{
tokens.Add(new MathToken(MathTokenType.Numeric, value));
i += charLength - 1; // advance the end of the token
expectNumber = false; // next token should be an operator
}
else
{
// Error case -- next token is not a number
return(new List <MathToken>());
}
}
}
else
{
if (c_numberBoxOperators.IndexOf(nextChar) > -1)
{
tokens.Add(new MathToken(MathTokenType.Operator, nextChar));
expectNumber = true; // next token should be a number
}
else if (nextChar == ')')
{
// Closed parens are also acceptable, but don't change the next expected token type.
tokens.Add(new MathToken(MathTokenType.Parenthesis, nextChar));
}
else
{
// Error case -- could not evaluate part of the expression
return(new List <MathToken>());
}
}
}
i++;
}
return(tokens);
}
public BaseDecoratedNumberParser(INumberParser numberParser)
{
_numberParser = numberParser;
}
