Write a python function which does min-max normalization with provided values for min and max. Note that the provided values can be optional. Handle all edge cases and use numpy.
Here's a Python function that performs min-max normalization using NumPy. It takes an input array, and optional minimum and maximum values for normalization. The function handles edge cases such as when the input array is empty or when the provided minimum and maximum values are equal.

```python
import numpy as np

def min_max_normalization(arr, provided_min=None, provided_max=None):
    if len(arr) == 0:
        raise ValueError(Input array cannot be empty.)
    
    arr = np.array(arr)
    
    if provided_min is not None and provided_max is not None:
        if provided_min == provided_max:
            raise ValueError(Provided minimum and maximum values cannot be equal.)
        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(Input array must have at least two distinct values.)
    
    normalized_arr = (arr - min_value) / (max_value - min_value)
    return normalized_arr

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

# With provided min and max values:
normalized_arr2 = min_max_normalization(arr, provided_min=0, provided_max=12)
print(normalized_arr2)
```

This function takes an input array and optional minimum and maximum values. If the minimum and maximum values are not provided, it calculates them from the input array. Then, it performs min-max normalization using the specified or calculated minimum and maximum values.
Can you convert this into Go?
Sure! Here's an equivalent Go program:
```go
package main

import (
	errors
	fmt
)

func minMaxNormalization(arr []float64, providedMin, providedMax *float64) ([]float64, error) {
	if len(arr) == 0 {
		return nil, errors.New(input array cannot be empty)
	}

	var min, max float64
	if providedMin != nil && providedMax != nil {
		if *providedMin == *providedMax {
			return nil, errors.New(provided minimum and maximum values cannot be equal)
		}
		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(input array must have at least two distinct values)
	}

	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)
}
```
Note that, with the absence of the `numpy` module in Go, we have to calculate the minimum and maximum values of the input array manually using a loop.