Exemple #1
0
// InfixCalculator will calculate an infix calculation
func InfixCalculator(args []string) gcf.Const {
	var argsForCalculation []interface{}

	for _, arg := range args {
		if v, e := parsers.Value(arg); e == nil {
			argsForCalculation = append(argsForCalculation, v)
		} else {
			argsForCalculation = append(argsForCalculation, arg)
		}
	}

	calculation := gcf.MustCalculate(argsForCalculation...)

	return calculation
}
// PolishCalculator is a simple reverse polish calculator
func PolishCalculator(args []string) (value gcv.Value, err error) {
	for left, right := 0, len(args)-1; left < right; left, right = left+1, right-1 {
		args[left], args[right] = args[right], args[left]
	}

	stack := gcv.MakeValues()
	var operand1 gcv.Value
	var operand2 gcv.Value
	var result gcv.Value

	if len(args) <= 2 {
		err = errors.New("Not Enough Arguments")
		return
	}

	for _, argument := range args {
		if v, e := parsers.Value(argument); e == nil {
			stack.Append(v)
			continue
		}

		if stack.Len() > 1 {
			operand2, stack = dequeue(stack)
			operand1, stack = dequeue(stack)

			result, err = calculateV(operand1, operand2, argument)

			if err != nil {
				return
			}

			stack.Append(result)
		} else {
			err = errors.New("IndexOutOfBoundsException")
			return
		}
	}

	if stack.Len() != 1 {
		err = errors.New("Multiple Final Values")
		return
	}

	value = stack.Get(0)
	return
}