Kannst du das in Go umwandeln?
Schreibe eine Python-Funktion, die eine Min-Max-Normalisierung mit den angegebenen Werten für min und max durchführt. Beachte, dass die angegebenen Werte optional sein können. Behandle alle Randfälle und verwende numpy. Hier ist eine Python-Funktion, die mithilfe von NumPy eine Min-Max-Normalisierung durchführt. Sie nimmt ein Eingabe-Array und optional Mindest- und Höchstwerte für die Normalisierung an. Die Funktion behandelt Randfälle wie ein leeres Eingabe-Array oder wenn die angegebenen Mindest- und Höchstwerte gleich sind.

```python
import numpy as np

def min_max_normalization(arr, provided_min=None, provided_max=None):
    if len(arr) == 0:
        raise ValueError("Das Eingabe-Array darf nicht leer sein.")
    
    arr = np.array(arr)
    
    if provided_min is not None and provided_max is not None:
        if provided_min == provided_max:
            raise ValueError("Die angegebenen Mindest- und Höchstwerte dürfen nicht gleich sein.")
        min_value, max_value = provided_min, provided_max
    else:
        min_value, max_value = np.min(arr), np.max(arr)

    if min_value == max_value:
        raise ValueError("Das Eingabe-Array muss mindestens zwei unterschiedliche Werte enthalten.")
    
    normalized_arr = (arr - min_value) / (max_value - min_value)
    return normalized_arr

# Beispielverwendung:
arr = [2, 4, 6, 8, 10]
normalized_arr = min_max_normalization(arr)
print(normalized_arr)

# Mit angegebenen Min- und Max-Werten:
normalized_arr2 = min_max_normalization(arr, provided_min=0, provided_max=12)
print(normalized_arr2)
```

Diese Funktion nimmt ein Eingabe-Array und optional Mindest- und Höchstwerte an. Wenn die Mindest- und Höchstwerte nicht angegeben werden, werden sie aus dem Eingabe-Array berechnet. Anschließend führt sie eine Min-Max-Normalisierung unter Verwendung der angegebenen oder berechneten Mindest- und Höchstwerte durch.
Natürlich! Hier ist ein äquivalentes Go-Programm:
```go
package main

import (
	"errors"
	"fmt"
)

func minMaxNormalization(arr []float64, providedMin, providedMax *float64) ([]float64, error) {
	if len(arr) == 0 {
		return nil, errors.New("Das Eingabe-Array darf nicht leer sein.")
	}

	var min, max float64
	if providedMin != nil && providedMax != nil {
		if *providedMin == *providedMax {
			return nil, errors.New("Die angegebenen Mindest- und Höchstwerte dürfen nicht gleich sein.")
		}
		min, max = *providedMin, *providedMax
	} else {
		min, max = arr[0], arr[0]
		for _, v := range arr {
			if v < min {
				min = v
			}
			if v > max {
				max = v
			}
		}
	}

	if min == max {
		return nil, errors.New("Das Eingabe-Array muss mindestens zwei unterschiedliche Werte enthalten.")
	}

	normalizedArr := make([]float64, len(arr))
	for i, v := range arr {
		normalizedArr[i] = (v - min) / (max - min)
	}
	return normalizedArr, nil
}

func main() {
	arr := []float64{2, 4, 6, 8, 10}

	normalizedArr, err := minMaxNormalization(arr, nil, nil)
	if err != nil {
		panic(err)
	}
	fmt.Println(normalizedArr)

	minVal := float64(0)
	maxVal := float64(12)
	normalizedArr2, err := minMaxNormalization(arr, &minVal, &maxVal)
	if err != nil {
		panic(err)
	}
	fmt.Println(normalizedArr2)
}
```
Beachte, dass wir in Go aufgrund des Fehlens des Moduls `numpy` die Mindest- und Höchstwerte des Eingabe-Arrays manuell mithilfe einer Schleife berechnen müssen.