Реализовать функцию func Calc(expression string) (float64, error) expression - строка-выражение состоящее из односимвольных идентификаторов и знаков арифметических действий Входящие данные - цифры(рациональные), операции +, -, *, /, операции приоритезации ( и ) В случае ошибки записи выражения функция выдает ошибку.

package main

import ( "errors" "strconv" "strings" )

func Calc(expression string) (float64, error) { expression = strings.ReplaceAll(expression, " ", "") // удаление всех пробелов из выражения

result, err := evaluateExpression(expression)
if err != nil {
	return 0, err
}

return result, nil

}

func evaluateExpression(expression string) (float64, error) { tokens := tokenize(expression)

// Проверка на пустое выражение
if len(tokens) == 0 {
	return 0, errors.New("empty expression")
}

// Преобразование инфиксной нотации в постфиксную
postfix, err := infixToPostfix(tokens)
if err != nil {
	return 0, err
}

// Вычисление значения выражения в постфиксной нотации
stack := []float64{}
for _, token := range postfix {
	if isOperator(token) {
		if len(stack) < 2 {
			return 0, errors.New("invalid expression")
		}
		operand2 := stack[len(stack)-1]
		operand1 := stack[len(stack)-2]
		stack = stack[:len(stack)-2]

		var result float64
		switch token {
		case "+":
			result = operand1 + operand2
		case "-":
			result = operand1 - operand2
		case "*":
			result = operand1 * operand2
		case "/":
			if operand2 == 0 {
				return 0, errors.New("division by zero")
			}
			result = operand1 / operand2
		}

		stack = append(stack, result)
	} else {
		value, err := strconv.ParseFloat(token, 64)
		if err != nil {
			return 0, errors.New("invalid token: " + token)
		}
		stack = append(stack, value)
	}
}

if len(stack) != 1 {
	return 0, errors.New("invalid expression")
}

return stack[0], nil

}

func tokenize(expression string) []string { tokens := []string{} token := ""

for _, char := range expression {
	if isOperator(string(char)) {
		if token != "" {
			tokens = append(tokens, token)
			token = ""
		}
		tokens = append(tokens, string(char))
	} else {
		token += string(char)
	}
}

if token != "" {
	tokens = append(tokens, token)
}

return tokens

}

func isOperator(token string) bool { return token == "+" || token == "-" || token == "*" || token == "/" }

func infixToPostfix(infix []string) ([]string, error) { postfix := []string{} stack := []string{}

for _, token := range infix {
	if !isOperator(token) && token != "(" && token != ")" {
		postfix = append(postfix, token)
	} else if token == "(" {
		stack = append(stack, token)
	} else if token == ")" {
		for len(stack) > 0 && stack[len(stack)-1] != "(" {
			postfix = append(postfix, stack[len(stack)-1])
			stack = stack[:len(stack)-1]
		}
		if len(stack) == 0 {
			return nil, errors.New("mismatched parentheses")
		}
		stack = stack[:len(stack)-1]
	} else {
		for len(stack) > 0 && precedence(stack[len(stack)-1]) >= precedence(token) {
			postfix = append(postfix, stack[len(stack)-1])
			stack = stack[:len(stack)-1]
		}
		stack = append(stack, token)
	}
}

for len(stack) > 0 {
	if stack[len(stack)-1] == "(" {
		return nil, errors.New("mismatched parentheses")
	}
	postfix = append(postfix, stack[len(stack)-1])
	stack = stack[:len(stack)-1]
}

return postfix, nil

}

func precedence(operator string) int { switch operator { case "+", "-": return 1 case "*", "/": return 2 } return 0 }