これがGOのMin-MAX正規化関数です：
    
    
「行きます
パッケージメイン

輸入 （
「エラー」
「FMT」
"算数"
））

func minmaxnormalization（arr [] float64、redumingmin *float64、revidmax *float64）（[] float64、error）{
LEN（arr）== 0の場合{
nil、errors.new（ "入力配列は空になることはできません"）を返します）
}

Var Minval、Maxval Float64
reventmin！= nil && suldmax！= nil {
if *revidmin == *revidmax {
nil、errors.newを返します（「提供された最小値と最大値が等しくない」）
}
Minval、maxval = *revidmin、 *revidmax
} それ以外 {
Minval、maxval = arr [0]、arr [0]
_、val：= range arr {
val <minvalの場合{
minval = val
}
val> maxvalの場合{
maxval = val
}
}
}

minval == maxvalの場合{
nil、errors.new（ "入力配列には少なくとも2つの異なる値が必要です"））
}

remarizedarr：= make（[] float64、len（arr））
i、val：= range arr {
remarizedarr [i] =（val -minval） /（maxval -minval）
}

return remarizedarr、nil
}

func main（）{
arr：= [] float64 {2、4、6、8、10}
remarizedarr、err：= minmaxnormalization（arr、nil、nil）
err！= nil {
fmt.println（err）
} それ以外 {
fmt.println（remormizedArr）
}

Minval、Maxval：= 0.0、12.0
remarizedarr2、err：= minmaxnormalization（arr、＆＆minval、＆maxval）
err！= nil {
fmt.println（err）
} それ以外 {
fmt.println（remarizedarr2）
}
}
`` `

このGO関数は、提供したPythonの機能と同じ機能を持っています。入力配列とオプションの最小値と最大値が必要です。最小値と最大値が提供されていない場合、入力配列からそれらを計算します。次に、指定または計算された最小値と最大値を使用して、MIN-MAX正規化を実行します。
Here's the min-max normalization function in Go:
    
    
```go
package main

import (
	"errors"
	"fmt"
	"math"
)

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

	var minVal, maxVal float64
	if providedMin != nil && providedMax != nil {
		if *providedMin == *providedMax {
			return nil, errors.New("Provided minimum and maximum values cannot be equal")
		}
		minVal, maxVal = *providedMin, *providedMax
	} else {
		minVal, maxVal = arr[0], arr[0]
		for _, val := range arr {
			if val < minVal {
				minVal = val
			}
			if val > maxVal {
				maxVal = val
			}
		}
	}

	if minVal == maxVal {
		return nil, errors.New("Input array must have at least two distinct values")
	}

	normalizedArr := make([]float64, len(arr))
	for i, val := range arr {
		normalizedArr[i] = (val - minVal) / (maxVal - minVal)
	}

	return normalizedArr, nil
}

func main() {
	arr := []float64{2, 4, 6, 8, 10}
	normalizedArr, err := minMaxNormalization(arr, nil, nil)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(normalizedArr)
	}

	minVal, maxVal := 0.0, 12.0
	normalizedArr2, err := minMaxNormalization(arr, &minVal, &maxVal)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(normalizedArr2)
	}
}
```

This Go function has the same functionality as the Python one you provided. It 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.