Merge pull request #230 from wipsel/228-rename-get-version-methods

wipsel · web-flow · commit 5c0545074e71 · 2024-12-22T11:18:20.000Z
Renamed all version getters #228
diff --git a/ops/abs/versions.go b/ops/abs/versions.go
@@ -9,6 +9,6 @@ var absVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newAbs, 13, absTypeConstraint),
 }
 
-func GetAbsVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return absVersions
 }
diff --git a/ops/acos/versions.go b/ops/acos/versions.go
@@ -8,6 +8,6 @@ var acosVersions = ops.OperatorVersions{
 	7: newAcos,
 }
 
-func GetAcosVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return acosVersions
 }
diff --git a/ops/acosh/versions.go b/ops/acosh/versions.go
@@ -8,6 +8,6 @@ var acoshVersions = ops.OperatorVersions{
 	9: newAcosh,
 }
 
-func GetAcoshVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return acoshVersions
 }
diff --git a/ops/add/versions.go b/ops/add/versions.go
@@ -9,6 +9,6 @@ var addVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newAdd, 13, addTypeConstraints),
 }
 
-func GetAddVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return addVersions
 }
diff --git a/ops/and/versions.go b/ops/and/versions.go
@@ -8,6 +8,6 @@ var andVersions = ops.OperatorVersions{
 	7: ops.NewOperatorConstructor(newAnd, 7, andTypeConstraints),
 }
 
-func GetAndVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return andVersions
 }
diff --git a/ops/argmax/versions.go b/ops/argmax/versions.go
@@ -10,6 +10,6 @@ var argMaxVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newArgMax, 13, argMaxTypeConstraints),
 }
 
-func GetArgMaxVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return argMaxVersions
 }
diff --git a/ops/asin/versions.go b/ops/asin/versions.go
@@ -8,6 +8,6 @@ var asinVersions = ops.OperatorVersions{
 	7: ops.NewOperatorConstructor(newAsin, 7, asinTypeConstraints),
 }
 
-func GetAsinVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return asinVersions
 }
diff --git a/ops/asinh/versions.go b/ops/asinh/versions.go
@@ -8,6 +8,6 @@ var asinhVersions = ops.OperatorVersions{
 	9: ops.NewOperatorConstructor(newAsinh, 9, asinhTypeConstraints),
 }
 
-func GetAsinhVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return asinhVersions
 }
diff --git a/ops/atan/versions.go b/ops/atan/versions.go
@@ -8,6 +8,6 @@ var atanVersions = ops.OperatorVersions{
 	7: ops.NewOperatorConstructor(newAtan, 7, atanTypeConstraints),
 }
 
-func GetAtanVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return atanVersions
 }
diff --git a/ops/atanh/versions.go b/ops/atanh/versions.go
@@ -8,6 +8,6 @@ var atanhVersions = ops.OperatorVersions{
 	9: ops.NewOperatorConstructor(newAtanh, 9, atanhTypeConstraints),
 }
 
-func GetAtanhVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return atanhVersions
 }
diff --git a/ops/cast/versions.go b/ops/cast/versions.go
@@ -10,6 +10,6 @@ var castVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newCast, 13, castTypeConstraints),
 }
 
-func GetCastVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return castVersions
 }
diff --git a/ops/concat/versions.go b/ops/concat/versions.go
@@ -10,6 +10,6 @@ var concatVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newConcat, 13, concatTypeConstraints),
 }
 
-func GetConcatVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return concatVersions
 }
diff --git a/ops/constant/versions.go b/ops/constant/versions.go
@@ -13,6 +13,6 @@ var constantVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newConstant, 13, [][]tensor.Dtype{}),
 }
 
-func GetConstantVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return constantVersions
 }
diff --git a/ops/constantofshape/versions.go b/ops/constantofshape/versions.go
@@ -8,6 +8,6 @@ var constantOfShapeVersions = ops.OperatorVersions{
 	9: ops.NewOperatorConstructor(newConstantOfShape, 9, constantOfShapeTypeConstraints),
 }
 
-func GetConstantOfShapeVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return constantOfShapeVersions
 }
diff --git a/ops/conv/versions.go b/ops/conv/versions.go
@@ -9,6 +9,6 @@ var convVersions = ops.OperatorVersions{
 	11: ops.NewOperatorConstructor(newConv, 11, convTypeConstraints),
 }
 
-func GetConvVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return convVersions
 }
diff --git a/ops/cos/versions.go b/ops/cos/versions.go
@@ -8,6 +8,6 @@ var cosVersions = ops.OperatorVersions{
 	7: ops.NewOperatorConstructor(newCos, 7, cosTypeConstraints),
 }
 
-func GetCosVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return cosVersions
 }
diff --git a/ops/cosh/versions.go b/ops/cosh/versions.go
@@ -8,6 +8,6 @@ var coshVersions = ops.OperatorVersions{
 	9: ops.NewOperatorConstructor(newCosh, 9, coshTypeConstraints),
 }
 
-func GetCoshVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return coshVersions
 }
diff --git a/ops/div/versions.go b/ops/div/versions.go
@@ -9,6 +9,6 @@ var divVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newDiv, 13, divTypeConstraints),
 }
 
-func GetDivVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return divVersions
 }
diff --git a/ops/equal/versions.go b/ops/equal/versions.go
@@ -10,6 +10,6 @@ var equalVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newEqual, 13, equalTypeConstraints),
 }
 
-func GetEqualVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return equalVersions
 }
diff --git a/ops/expand/versions.go b/ops/expand/versions.go
@@ -8,6 +8,6 @@ var expandVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newExpand, 13, expandTypeConstraints),
 }
 
-func GetExpandVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return expandVersions
 }
diff --git a/ops/flatten/versions.go b/ops/flatten/versions.go
@@ -12,6 +12,6 @@ var flattenVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newFlatten, 13, [][]tensor.Dtype{ops.AllTypes}),
 }
 
-func GetFlattenVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return flattenVersions
 }
diff --git a/ops/gather/versions.go b/ops/gather/versions.go
@@ -8,6 +8,6 @@ var gatherVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newGather, 13, gatherTypeConstraints),
 }
 
-func GetGatherVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return gatherVersions
 }
diff --git a/ops/gemm/versions.go b/ops/gemm/versions.go
@@ -20,6 +20,6 @@ var gemmVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newGemm, 13, gemmTypeConstraints),
 }
 
-func GetGemmVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return gemmVersions
 }
diff --git a/ops/greater/versions.go b/ops/greater/versions.go
@@ -8,6 +8,6 @@ var greaterVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newGreater, 13, greaterTypeConstraints),
 }
 
-func GetGreaterVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return greaterVersions
 }
diff --git a/ops/greaterorequal/versions.go b/ops/greaterorequal/versions.go
@@ -6,6 +6,6 @@ var greaterOrEqualVersions = ops.OperatorVersions{
 	12: ops.NewOperatorConstructor(newGreaterOrEqual, 12, greaterOrEqualTypeConstraints),
 }
 
-func GetGreaterOrEqualVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return greaterOrEqualVersions
 }
diff --git a/ops/gru/gru.go b/ops/gru/gru.go
@@ -212,7 +212,7 @@ func (g *GRU) extractXt(X tensor.Tensor, t int) (tensor.Tensor, error) {
 func (g *GRU) gateCalculation(
 	Xt, H, W, R, Wb, Rb tensor.Tensor, activation ops.Activation,
 ) (tensor.Tensor, error) {
-	gemm := gemm.GetGemmVersions()[13]()
+	gemm := gemm.GetVersions()[13]()
 
 	err := gemm.Init(
 		&onnx.NodeProto{
@@ -258,7 +258,7 @@ func (g *GRU) htCalculation(
 		return g.gateCalculation(Xt, temp1, W, R, Wb, Rb, activation)
 	}
 
-	gemm := gemm.GetGemmVersions()[13]()
+	gemm := gemm.GetVersions()[13]()
 
 	err := gemm.Init(
 		&onnx.NodeProto{
diff --git a/ops/gru/versions.go b/ops/gru/versions.go
@@ -6,6 +6,6 @@ var gruVersions = ops.OperatorVersions{
 	7: ops.NewOperatorConstructor(newGRU, 7, gruTypeConstraints),
 }
 
-func GetGRUVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return gruVersions
 }
diff --git a/ops/less/versions.go b/ops/less/versions.go
@@ -8,6 +8,6 @@ var lessVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newLess, 13, lessTypeConstraints),
 }
 
-func GetLessVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return lessVersions
 }
diff --git a/ops/lessorequal/versions.go b/ops/lessorequal/versions.go
@@ -6,6 +6,6 @@ var lessOrEqualVersions = ops.OperatorVersions{
 	12: ops.NewOperatorConstructor(newLessOrEqual, 12, lessOrEqualTypeConstraints),
 }
 
-func GetLessOrEqualVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return lessOrEqualVersions
 }
diff --git a/ops/linearregressor/versions.go b/ops/linearregressor/versions.go
@@ -6,6 +6,6 @@ var linearRegressorVersions = ops.OperatorVersions{
 	1: ops.NewOperatorConstructor(newLinearRegressor, 1, linearRegressorTypeConstraints),
 }
 
-func GetLinearRegressorVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return linearRegressorVersions
 }
diff --git a/ops/logsoftmax/versions.go b/ops/logsoftmax/versions.go
@@ -8,6 +8,6 @@ var logSoftmaxVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newLogSoftmax, 13, logSoftmaxTypeConstraints),
 }
 
-func GetLogSoftmaxVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return logSoftmaxVersions
 }
diff --git a/ops/lstm/lstm.go b/ops/lstm/lstm.go
@@ -278,7 +278,7 @@ func (l *LSTM) Apply(inputs []tensor.Tensor) ([]tensor.Tensor, error) {
 func (l *LSTM) gateCalculation(
 	Xt, W, Wb, H, R, Rb, P, C tensor.Tensor, activation ops.Activation,
 ) (tensor.Tensor, error) {
-	gemm := gemm.GetGemmVersions()[13]()
+	gemm := gemm.GetVersions()[13]()
 
 	err := gemm.Init(
 		&onnx.NodeProto{
diff --git a/ops/lstm/versions.go b/ops/lstm/versions.go
@@ -6,6 +6,6 @@ var lstmVersions = ops.OperatorVersions{
 	7: ops.NewOperatorConstructor(newLSTM, 7, lstmTypeConstraints),
 }
 
-func GetLSTMVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return lstmVersions
 }
diff --git a/ops/matmul/versions.go b/ops/matmul/versions.go
@@ -8,6 +8,6 @@ var matMulVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newMatMul, 13, matmulTypeConstraints),
 }
 
-func GetMatMulVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return matMulVersions
 }
diff --git a/ops/mul/versions.go b/ops/mul/versions.go
@@ -7,6 +7,6 @@ var mulVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newMul, 13, mulTypeConstraints),
 }
 
-func GetMulVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return mulVersions
 }
diff --git a/ops/not/versions.go b/ops/not/versions.go
@@ -6,6 +6,6 @@ var notVersions = ops.OperatorVersions{
 	1: ops.NewOperatorConstructor(newNot, 1, notTypeConstraints),
 }
 
-func GetNotVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return notVersions
 }
diff --git a/ops/or/versions.go b/ops/or/versions.go
@@ -6,6 +6,6 @@ var orVersions = ops.OperatorVersions{
 	7: ops.NewOperatorConstructor(newOr, 7, orTypeConstraints),
 }
 
-func GetOrVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return orVersions
 }
diff --git a/ops/prelu/versions.go b/ops/prelu/versions.go
@@ -10,6 +10,6 @@ var preluVersions = ops.OperatorVersions{
 	9: ops.NewOperatorConstructor(newPRelu, 9, preluTypeConstraints),
 }
 
-func GetPReluVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return preluVersions
 }
diff --git a/ops/reducemax/versions.go b/ops/reducemax/versions.go
@@ -9,6 +9,6 @@ var reduceMaxVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newReduceMax, 13, reduceMaxTypeConstraints),
 }
 
-func GetReduceMaxVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return reduceMaxVersions
 }
diff --git a/ops/reducemin/versions.go b/ops/reducemin/versions.go
@@ -9,6 +9,6 @@ var reduceMinVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newReduceMin, 13, reduceMinTypeConstraints),
 }
 
-func GetReduceMinVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return reduceMinVersions
 }
diff --git a/ops/relu/versions.go b/ops/relu/versions.go
@@ -7,6 +7,6 @@ var reluVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newRelu, 13, reluTypeConstraints),
 }
 
-func GetReluVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return reluVersions
 }
diff --git a/ops/reshape/versions.go b/ops/reshape/versions.go
@@ -7,6 +7,6 @@ var reshapeVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newReshape, 13, reshapeTypeConstraints),
 }
 
-func GetReshapeVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return reshapeVersions
 }
diff --git a/ops/rnn/rnn.go b/ops/rnn/rnn.go
@@ -183,7 +183,7 @@ func (r *RNN) Apply(inputs []tensor.Tensor) ([]tensor.Tensor, error) {
 func (r *RNN) layerCalculation(
 	Xt, H, Wi, Ri, Wbi, Rbi tensor.Tensor, activation ops.Activation,
 ) (tensor.Tensor, error) {
-	gemm := gemm.GetGemmVersions()[13]()
+	gemm := gemm.GetVersions()[13]()
 
 	err := gemm.Init(
 		&onnx.NodeProto{
diff --git a/ops/rnn/versions.go b/ops/rnn/versions.go
@@ -6,6 +6,6 @@ var rnnVersions = ops.OperatorVersions{
 	7: ops.NewOperatorConstructor(newRNN, 7, rnnTypeConstraints),
 }
 
-func GetRNNVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return rnnVersions
 }
diff --git a/ops/scaler/versions.go b/ops/scaler/versions.go
@@ -6,6 +6,6 @@ var scalerVersions = ops.OperatorVersions{
 	1: ops.NewOperatorConstructor(newScaler, 1, scalerTypeConstraints),
 }
 
-func GetScalerVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return scalerVersions
 }
diff --git a/ops/shape/versions.go b/ops/shape/versions.go
@@ -7,6 +7,6 @@ var shapeVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newShape, 13, shapeTypeConstraints),
 }
 
-func GetShapeVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return shapeVersions
 }
diff --git a/ops/sigmoid/versions.go b/ops/sigmoid/versions.go
@@ -7,6 +7,6 @@ var sigmoidVersions = ops.OperatorVersions{
 	13: ops.NewOperatorConstructor(newSigmoid, 13, sigmoidTypeConstraints),
 }
 
-func GetSigmoidVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return sigmoidVersions
 }
diff --git a/ops/sin/versions.go b/ops/sin/versions.go
@@ -6,6 +6,6 @@ var sinVersions = ops.OperatorVersions{
 	7: ops.NewOperatorConstructor(newSin, 7, sinTypeConstraints),
 }
 
-func GetSinVersions() ops.OperatorVersions {
+func GetVersions() ops.OperatorVersions {
 	return sinVersions
 }
diff --git a/ops/sinh/versions.go b/ops/sinh/versions.go
diff --git a/ops/slice/versions.go b/ops/slice/versions.go
diff --git a/ops/softmax/versions.go b/ops/softmax/versions.go
diff --git a/ops/squeeze/versions.go b/ops/squeeze/versions.go
diff --git a/ops/sub/versions.go b/ops/sub/versions.go
diff --git a/ops/tan/versions.go b/ops/tan/versions.go
diff --git a/ops/tanh/versions.go b/ops/tanh/versions.go
diff --git a/ops/transpose/versions.go b/ops/transpose/versions.go
diff --git a/ops/unsqueeze/versions.go b/ops/unsqueeze/versions.go
diff --git a/ops/xor/versions.go b/ops/xor/versions.go
diff --git a/opset.go b/opset.go

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,6 @@ var absVersions = ops.OperatorVersions{`
`9`	`9`	`13: ops.NewOperatorConstructor(newAbs, 13, absTypeConstraint),`
`10`	`10`	`}`
`11`	`11`
`12`		`-func GetAbsVersions() ops.OperatorVersions {`
	`12`	`+func GetVersions() ops.OperatorVersions {`
`13`	`13`	`return absVersions`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,6 @@ var acosVersions = ops.OperatorVersions{`
`8`	`8`	`7: newAcos,`
`9`	`9`	`}`
`10`	`10`
`11`		`-func GetAcosVersions() ops.OperatorVersions {`
	`11`	`+func GetVersions() ops.OperatorVersions {`
`12`	`12`	`return acosVersions`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,6 @@ var acoshVersions = ops.OperatorVersions{`
`8`	`8`	`9: newAcosh,`
`9`	`9`	`}`
`10`	`10`
`11`		`-func GetAcoshVersions() ops.OperatorVersions {`
	`11`	`+func GetVersions() ops.OperatorVersions {`
`12`	`12`	`return acoshVersions`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,6 @@ var addVersions = ops.OperatorVersions{`
`9`	`9`	`13: ops.NewOperatorConstructor(newAdd, 13, addTypeConstraints),`
`10`	`10`	`}`
`11`	`11`
`12`		`-func GetAddVersions() ops.OperatorVersions {`
	`12`	`+func GetVersions() ops.OperatorVersions {`
`13`	`13`	`return addVersions`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,6 @@ var andVersions = ops.OperatorVersions{`
`8`	`8`	`7: ops.NewOperatorConstructor(newAnd, 7, andTypeConstraints),`
`9`	`9`	`}`
`10`	`10`
`11`		`-func GetAndVersions() ops.OperatorVersions {`
	`11`	`+func GetVersions() ops.OperatorVersions {`
`12`	`12`	`return andVersions`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,6 @@ var argMaxVersions = ops.OperatorVersions{`
`10`	`10`	`13: ops.NewOperatorConstructor(newArgMax, 13, argMaxTypeConstraints),`
`11`	`11`	`}`
`12`	`12`
`13`		`-func GetArgMaxVersions() ops.OperatorVersions {`
	`13`	`+func GetVersions() ops.OperatorVersions {`
`14`	`14`	`return argMaxVersions`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,6 @@ var asinVersions = ops.OperatorVersions{`
`8`	`8`	`7: ops.NewOperatorConstructor(newAsin, 7, asinTypeConstraints),`
`9`	`9`	`}`
`10`	`10`
`11`		`-func GetAsinVersions() ops.OperatorVersions {`
	`11`	`+func GetVersions() ops.OperatorVersions {`
`12`	`12`	`return asinVersions`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,6 @@ var asinhVersions = ops.OperatorVersions{`
`8`	`8`	`9: ops.NewOperatorConstructor(newAsinh, 9, asinhTypeConstraints),`
`9`	`9`	`}`
`10`	`10`
`11`		`-func GetAsinhVersions() ops.OperatorVersions {`
	`11`	`+func GetVersions() ops.OperatorVersions {`
`12`	`12`	`return asinhVersions`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,6 @@ var atanVersions = ops.OperatorVersions{`
`8`	`8`	`7: ops.NewOperatorConstructor(newAtan, 7, atanTypeConstraints),`
`9`	`9`	`}`
`10`	`10`
`11`		`-func GetAtanVersions() ops.OperatorVersions {`
	`11`	`+func GetVersions() ops.OperatorVersions {`
`12`	`12`	`return atanVersions`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,6 @@ var atanhVersions = ops.OperatorVersions{`
`8`	`8`	`9: ops.NewOperatorConstructor(newAtanh, 9, atanhTypeConstraints),`
`9`	`9`	`}`
`10`	`10`
`11`		`-func GetAtanhVersions() ops.OperatorVersions {`
	`11`	`+func GetVersions() ops.OperatorVersions {`
`12`	`12`	`return atanhVersions`
`13`	`13`	`}`