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

package main

import ( "fmt" "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)

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

// Вычисление значения выражения по постфиксной нотации
result, err := evaluatePostfix(postfixTokens)
if err != nil {
	return 0, err
}

return result, nil

}

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

for _, char := range expression {
	if char == '+' || char == '-' || char == '*' || char == '/' || char == '(' || 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 infixToPostfix(tokens []string) ([]string, error) { var postfix []string var stack []string

precedence := map[string]int{
	"+": 1,
	"-": 1,
	"*": 2,
	"/": 2,
}

for _, token := range tokens {
	if isNumber(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, fmt.Errorf("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, fmt.Errorf("Mismatched parentheses")
	}
	postfix = append(postfix, stack[len(stack)-1])
	stack = stack[:len(stack)-1]
}

return postfix, nil

}

func evaluatePostfix(tokens []string) (float64, error) { var stack []float64

for _, token := range tokens {
	if isNumber(token) {
		num, err := strconv.ParseFloat(token, 64)
		if err != nil {
			return 0, err
		}
		stack = append(stack, num)
	} else {
		if len(stack) < 2 {
			return 0, fmt.Errorf("Invalid expression")
		}
		num2 := stack[len(stack)-1]
		num1 := stack[len(stack)-2]
		stack = stack[:len(stack)-2]

		var result float64
		switch token {
		case "+":
			result = num1 + num2
		case "-":
			result = num1 - num2
		case "*":
			result = num1 * num2
		case "/":
			if num2 == 0 {
				return 0, fmt.Errorf("Division by zero")
			}
			result = num1 / num2
		}

		stack = append(stack, result)
	}
}

if len(stack) != 1 {
	return 0, fmt.Errorf("Invalid expression")
}

return stack[0], nil

}

func isNumber(token string) bool { _, err := strconv.ParseFloat(token, 64) return err == nil }

func main() { result, err := Calc("3 + 4 * 2 / (1 - 5)^2") if err != nil { fmt.Println("Error:", err) } else { fmt.Println("Result:", result) } }