public IOperation CreateOperation(OperationTypes operationType)
{
IOperation newOperation = null;
switch (operationType)
{
case OperationTypes.Addition:
newOperation = new AdditionOperation();
break;
case OperationTypes.Subtraction:
newOperation = new SubtractionOperation();
break;
case OperationTypes.Multiplication:
newOperation = new MultiplicationOperation();
break;
case OperationTypes.Division:
newOperation = new DivisionOperation();
break;
case OperationTypes.Modulus:
newOperation = new ModulusOperation();
break;
case OperationTypes.Undefined:
newOperation = new NullOperation();
break;
}
return(newOperation);
}
public override void Calculation()
{
Func <double, double, double> operation;
switch (_operator)
{
case '+':
operation = new SumOperation(_resultInfo).Execute;
break;
case '-':
operation = new SubtractionOperation(_resultInfo).Execute;
break;
case '*':
operation = new MultiplicationOperation(_resultInfo).Execute;
break;
case '/':
operation = new DivisionOperation(_resultInfo).Execute;
break;
default:
throw new Exception($"Error: Incorrect operation: {_operator}");
}
_resultInfo.ResultValue = new SimpleInputDataAnalyzer <TResultInfo>(_resultInfo).Analysis(_firstArgument, _secondArgument, operation).Execute();
}
private IOperation GetOperationByName(string name)
{
IOperation operation = null;
switch (name)
{
case "+":
operation = new AddOperation();
break;
case "-":
operation = new SubOperation();
break;
case "*":
operation = new MultiOperation();
break;
case "/":
operation = new DivisionOperation();
break;
case "^":
operation = new ExpOperation();
break;
default:
break;
}
return(operation);
}
public override HlslTreeNode Reduce()
{
var squareRoot = new SquareRootOperation(Value);
var division = new DivisionOperation(new ConstantNode(1), squareRoot);
Replace(division);
return(division);
}
public void operationhandler()
{
IArithmaticOperation addition = new AdditionOperation();
IArithmaticOperation subtraction = new SubtractionOperation();
IArithmaticOperation multiplication = new MultiplicationOperation();
IArithmaticOperation division = new DivisionOperation();
addition.setNext(subtraction);
subtraction.setNext(multiplication);
multiplication.setNext(division);
Request request = new Request(_num1, _num2);
addition.Operation(request);
}
static void Main(string[] args)
{
var gen = new StringSearchGenerator();
var options = new StringSearchGeneratorOptions()
{
Width = 10,
Height = 10,
Directions = new List <CellDirection>()
{
CellDirection.Right, CellDirection.Down
},
Title = "Test Math Search",
FillerCharacters = Defaults.Numbers,
};
for (int i = 0; i < 100; i++)
{
var probs = new List <IMathOperation>()
{
MultiplicationOperation.NewRandom(25, 100),
AdditionOperation.NewRandom(100, 100000),
SubtractionOperation.NewRandomNonNegative(1, 100),
DivisionOperation.NewRandomIntegerResult(10, 100)
};
var prob = probs.GetRandom();
if (prob.ValueDisplay.Length > 1)
{
options.ItemsToPlace.Add(new MathProblemPuzzleEntry(prob));
}
}
var puzzle = gen.Generate(options);
Console.WriteLine(puzzle.Title);
Console.WriteLine();
Console.WriteLine(puzzle.Grid.ToString());
Console.WriteLine();
puzzle.Items.ForEach(i => Console.WriteLine(i.DisplayValue));
Console.WriteLine();
Console.ReadLine();
}
private IEnumerable <IPuzzleEntry> RandomMathProblemsForPuzzle()
{
while (true)
{
var probs = new List <IMathOperation>()
{
MultiplicationOperation.NewRandom(25, 100),
AdditionOperation.NewRandom(100, 100000),
SubtractionOperation.NewRandomNonNegative(1, 100),
DivisionOperation.NewRandomIntegerResult(10, 100)
};
var prob = probs.GetRandom();
if (prob.ValueDisplay.Length > 1)
{
yield return(new MathProblemPuzzleEntry(prob));
}
}
}
static void Main(string[] args)
{
var parser = new InputStringParser();
IOperation operation = new AdditionOperation();;
var argValues = CommandLine.Parser.Default.ParseArguments <CommandLineArgumentOptions>(args);
if (!argValues.Errors.Any())
{
// Values are available here
if (!string.IsNullOrEmpty(argValues.Value.AlternateDelimiter))
{
parser.Settings.Delimiters.Add(argValues.Value.AlternateDelimiter);
}
parser.Settings.AllowNegativeValues = argValues.Value.AllowNegativeValues;
parser.Settings.MaximumValue = argValues.Value.MaximumValue;
if (argValues.Value.Operation == Operations.Add)
{
operation = new AdditionOperation();
}
else if (argValues.Value.Operation == Operations.Subtract)
{
operation = new SubtractionOperation();
}
else if (argValues.Value.Operation == Operations.Multiply)
{
operation = new MultiplicationOperation();
}
else if (argValues.Value.Operation == Operations.Divide)
{
operation = new DivisionOperation();
}
}
else
{
return;
}
var calculator = new StringCalculator(parser);
Console.WriteLine(calculator.PromptString);
Console.WriteLine("Multiline strings may be entered. Input an empty line to terminate the input. " +
"The application will repeat execution until the console is closed or terminated with 'Ctrl+C'");
while (true)
{
try
{
string line;
string input = string.Empty;
while (!String.IsNullOrWhiteSpace(line = Console.ReadLine()))
{
input += line + "\n";
}
var result = calculator.Calculate(input.Trim(), operation).NumberSentence;
Console.WriteLine($"Result: {result}");
}
catch (Exception ex)
{
Console.WriteLine($"Error Calculating Value. Error details: {ex.Message}");
}
Console.WriteLine("\n");
}
}
public override HlslTreeNode Reduce()
{
var factor1 = Factor1.Reduce();
var factor2 = Factor2.Reduce();
var constant1 = factor1 as ConstantNode;
var constant2 = factor2 as ConstantNode;
if (constant1 != null)
{
float value1 = constant1.Value;
if (value1 == 0)
{
Replace(factor1);
return(factor1);
}
if (value1 == 1)
{
Replace(factor2);
return(factor2);
}
if (value1 == -1)
{
var negation = new NegateOperation(factor2);
Replace(negation);
return(negation);
}
if (constant2 != null)
{
return(new ConstantNode(value1 * constant2.Value));
}
// TODO: Replace with division by x only if dividend is an addition of x addends
/*
* if (IsFractional(value1))
* {
* ConstantNode divisor = new ConstantNode(1 / value1);
* var division = new DivisionOperation(factor2, divisor);
* Replace(division);
* return division;
* }
*/
}
if (constant2 != null)
{
float value2 = constant2.Value;
if (value2 == 0)
{
Replace(factor2);
return(factor2);
}
if (value2 == 1)
{
Replace(factor1);
return(factor1);
}
if (value2 == -1)
{
var negation = new NegateOperation(factor1);
Replace(negation);
return(negation);
}
// TODO: Replace with division by x only if dividend is an addition of x addends
/*
* if (IsFractional(value2))
* {
* ConstantNode divisor = new ConstantNode(1 / value2);
* var division = new DivisionOperation(factor1, divisor);
* Replace(division);
* return division;
* }
*/
}
if (factor1 is DivisionOperation reciprocalDivision)
{
if (reciprocalDivision.Dividend is ConstantNode one && one.Value == 1)
{
var division = new DivisionOperation(factor2, reciprocalDivision.Divisor);
Replace(division);
return(division);
}
}
Inputs[0] = factor1;
Inputs[1] = factor2;
return(this);
}
