fix: static analysis and lint check

Author: KEINOS

.golangci.yml

@@ -97,7 +97,7 @@ linters-settings:
     statements: 40
   gocognit:
     # minimal code complexity to report, 30 by default (but we recommend 10-20)
-    min-complexity: 10
+    min-complexity: 15
   gocritic:
     # Which checks should be enabled; can't be combined with 'disabled-checks';
     # See https://go-critic.github.io/overview#checks-overview
@@ -114,7 +114,7 @@ linters-settings:
         sizeThreshold: 70
   gocyclo:
     # minimal code complexity to report, 30 by default (but we recommend 10-20)
-    min-complexity: 10
+    min-complexity: 15
   godot:
     # check that each sentence starts with a capital letter
     capital: true

README.md

@@ -14,11 +14,10 @@ In the example below, 1 dimmentional method `Noise.Eval64(x)` was used to genera
 //
 // noiseType := noise.Perlin
 // noiseType := noise.OpenSimplex
-n := noise.New(noiseType, seed)
+n, err := noise.New(noiseType, seed)
 
 yy := n.Eval64(x / smoothness) // yy is between -1.0 and 1.0 of float64
-
-y := (yy + 1) / 2 * 500 // y is between 0 and 500
+y := (yy + 1) / 2 * 500        // y is between 0 and 500
 ```
 
 ![](./_example/2d/2d_perlin.png)
@@ -30,8 +29,8 @@ y := (yy + 1) / 2 * 500 // y is between 0 and 500
 
 ```go
 // Obtain the noise value at the position (x, y)
-n := noise.New(noiseType, seed)
-v := n.Eval64(x, y) // y is between -1.0 and 1.0 of float64
+n, err := noise.New(noiseType, seed)
+v := n.Eval64(x, y) // v is between -1.0 and 1.0 of float64
 ```
 
 To create a 2D image, plot the `v` value at the position `(x, y)` in the 2D space. The 2D image example is equivalent to a frame of the 3D image example below.
@@ -46,8 +45,8 @@ The X and Y axes are the 2D image and the Z axis is the "time", or animation fra
 
 ```go
 // Obtain the noise value at the position (x, y, z)
-n := noise.New(noise.Perlin, seed)
-v := n.Eval64(x, y, z) // y is between -1.0 and 1.0 of float64
+n, err := noise.New(noise.Perlin, seed)
+v := n.Eval64(x, y, z) // v is between -1.0 and 1.0 of float64
 ```
 
 ![](./_example/3d/animation_perlin.gif)
@@ -58,8 +57,8 @@ v := n.Eval64(x, y, z) // y is between -1.0 and 1.0 of float64
 
 ```go
 // Obtain the noise value at the position (x, y, z)
-n := noise.New(noise.OpenSimplex, seed)
-v := n.Eval64(x, y, z) // y is between -1.0 and 1.0 of float64
+n, err := noise.New(noise.OpenSimplex, seed)
+v := n.Eval64(x, y, z) // v is between -1.0 and 1.0 of float64
 ```
 
 ![](./_example/3d/animation_opensimplex.gif)
@@ -135,6 +134,10 @@ const frame = 50
 // Create new noise generator of Perlin type
 genNoise, err := noise.New(noise.Perlin, seed)
 
+if err != nil {
+    // error handle
+}
+
 for z := 0; z < frame; z++ {
     zz := float64(z) / steps
 
@@ -165,3 +168,16 @@ for z := 0; z < frame; z++ {
 ```
 
 - [Complete Source](./_example/3d)
+
+#### Advanced
+
+To change `alpha` and `beta` values of Perling noise.
+
+```go
+alpha := 0.5
+beta := 0.5
+
+n, err := noise.New(noise.Perlin, seed)
+n.Smoothness = alpha
+n.Scale = beta
+```

example_test.go

@@ -9,7 +9,10 @@ import (
 )
 
 func ExampleNew() {
-	noise, err := noise.New(noise.OpenSimplex, rand.Int63())
+	//nolint:gosec // Example value
+	seed := rand.Int63()
+
+	noise, err := noise.New(noise.OpenSimplex, seed)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -31,7 +34,7 @@ func ExampleNew() {
 //  OpenSimplex Noise
 // ----------------------------------------------------------------------------
 
-func ExampleNew_one_dimention_opensimplex_noise_in_float32() {
+func ExampleNew_one_dimension_opensimplex_noise_in_float32() {
 	const seed = 100
 
 	gen, err := noise.New(noise.OpenSimplex, seed)
@@ -53,7 +56,7 @@ func ExampleNew_one_dimention_opensimplex_noise_in_float32() {
 	// 2;0.1385
 }
 
-func ExampleNew_two_dimention_opensimplex_noise_in_float32() {
+func ExampleNew_two_dimension_opensimplex_noise_in_float32() {
 	const seed = 100
 
 	gen, err := noise.New(noise.OpenSimplex, seed)
@@ -78,7 +81,7 @@ func ExampleNew_two_dimention_opensimplex_noise_in_float32() {
 	// 1;1;0.0950
 }
 
-func ExampleNew_three_dimention_opensimplex_noise_in_float32() {
+func ExampleNew_three_dimension_opensimplex_noise_in_float32() {
 	const seed = 100
 
 	gen, err := noise.New(noise.OpenSimplex, seed)
@@ -109,7 +112,7 @@ func ExampleNew_three_dimention_opensimplex_noise_in_float32() {
 	// 1;1;1;-0.1585
 }
 
-func ExampleNew_one_dimention_opensimplex_in_float64() {
+func ExampleNew_one_dimension_opensimplex_in_float64() {
 	const seed = 100
 
 	gen, err := noise.New(noise.OpenSimplex, seed)
@@ -125,9 +128,9 @@ func ExampleNew_one_dimention_opensimplex_in_float64() {
 	}
 
 	// Output:
-	// 0;0.0000
-	// 1;0.0950
-	// 2;0.1385
+	// 0.0000;0.0000
+	// 0.1000;0.0950
+	// 0.2000;0.1385
 }
 
 // ----------------------------------------------------------------------------

noise.go

@@ -6,11 +6,15 @@ import (
 	"github.com/pkg/errors"
 )
 
-type NoiseType int
+// Algo represents a noise type of the algorithm to generate noise.
+type Algo int
 
 const (
-	Unknown NoiseType = iota
+	// Unknown noise type.
+	Unknown Algo = iota
+	// Perlin noise type.
 	Perlin
+	// OpenSimplex noise type.
 	OpenSimplex
 )
 
@@ -43,7 +47,7 @@ type Noise interface {
 // ----------------------------------------------------------------------------
 
 // New returns a new noise generator.
-func New(noiseType NoiseType, seed int64) (Noise, error) {
+func New(noiseType Algo, seed int64) (Noise, error) {
 	switch noiseType {
 	case Perlin:
 		return perlin.New(seed), nil

pkg/opensimplex/opensimplex.go

@@ -17,13 +17,15 @@ func New(seed int64) *Noise {
 //  Type: Noise
 // ----------------------------------------------------------------------------
 
+// Noise holds parameter values for OpenSimplex noise. It is an implementation
+// of Noise interface.
 type Noise struct {
 	// Seed holds the seed value for the noise.
 	Seed int64
 }
 
 // ----------------------------------------------------------------------------
-//  Methods
+//  Methods (Public)
 // ----------------------------------------------------------------------------
 
 // Eval32 returns a float32 noise value for the given coordinates.
@@ -54,42 +56,46 @@ func (n *Noise) Eval64(dim ...float64) float64 {
 	return 0
 }
 
-// eval1D32 generates 1-dimensional OpenSimplex Noise value.
+// ----------------------------------------------------------------------------
+//  Methods (Private)
+// ----------------------------------------------------------------------------
+
+// eval1D32 generates float32 OpenSimplex noise value from 1-dimensional coordinate.
 func (n *Noise) eval1D32(x float32) float32 {
 	p := orig.New32(n.Seed)
 
 	return p.Eval2(x, x)
 }
 
-// eval2D32 generates 2-dimensional OpenSimplex Noise value.
+// eval2D32 generates float32 OpenSimplex noise value from 2-dimensional coordinates.
 func (n *Noise) eval2D32(x, y float32) float32 {
 	p := orig.New32(n.Seed)
 
 	return p.Eval2(x, y)
 }
 
-// eval3D32 generates 3-dimensional OpenSimplex Noise value.
+// eval3D32 generates float32 OpenSimplex noise value from 3-dimensional coordinates.
 func (n *Noise) eval3D32(x, y, z float32) float32 {
 	p := orig.New32(n.Seed)
 
 	return p.Eval3(x, y, z)
 }
 
-// eval1D64 generates 1-dimensional OpenSimplex Noise value.
+// eval1D64 generates float64 OpenSimplex noise value from 1-dimensional coordinate.
 func (n *Noise) eval1D64(x float64) float64 {
 	p := orig.New(n.Seed)
 
 	return p.Eval2(x, x)
 }
 
-// eval2D64 generates 2-dimensional OpenSimplex Noise value.
+// eval2D64 generates float64 OpenSimplex noise value from 2-dimensional coordinates.
 func (n *Noise) eval2D64(x, y float64) float64 {
 	p := orig.New(n.Seed)
 
 	return p.Eval2(x, y)
 }
 
-// eval3D64 generates 3-dimensional OpenSimplex Noise value.
+// eval3D64 generates float64 OpenSimplex noise value from 3-dimensional coordinates.
 func (n *Noise) eval3D64(x, y, z float64) float64 {
 	p := orig.New(n.Seed)
 

pkg/opensimplex/opensimplex_test.go

@@ -10,8 +10,41 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+// samples is a list of assert values for testing from the original OpenSimplex package.
 var samples [][]float64
 
+func TestSamplesMatch(t *testing.T) {
+	samples = loadSamples(t)
+
+	n := opensimplex.New(0)
+
+	for _, s := range samples {
+		var expected, actual float64
+
+		switch len(s) {
+		case 3:
+			expected = s[2]
+			actual = n.Eval64(s[0], s[1])
+		case 4:
+			expected = s[3]
+			actual = n.Eval64(s[0], s[1], s[2])
+		case 5:
+			continue
+		default:
+			t.Fatalf("Unexpected size sample: %d", len(s))
+		}
+
+		if expected != actual {
+			t.Fatalf("Expected %v, got %v for %dD sample at %v",
+				expected, actual, len(s)-1, s[:len(s)-1])
+		}
+	}
+}
+
+// ----------------------------------------------------------------------------
+//  Helper Functions
+// ----------------------------------------------------------------------------
+
 func loadSamples(t *testing.T) [][]float64 {
 	t.Helper()
 
@@ -25,6 +58,7 @@ func loadSamples(t *testing.T) [][]float64 {
 	defer f.Close()
 
 	dec := json.NewDecoder(f)
+
 	for {
 		var sample []float64
 
@@ -42,30 +76,3 @@ func loadSamples(t *testing.T) [][]float64 {
 
 	return samples
 }
-
-func TestSamplesMatch(t *testing.T) {
-	samples := loadSamples(t)
-
-	n := opensimplex.New(0)
-
-	for _, s := range samples {
-		var expected, actual float64
-		switch len(s) {
-		case 3:
-			expected = s[2]
-			actual = n.Eval64(s[0], s[1])
-		case 4:
-			expected = s[3]
-			actual = n.Eval64(s[0], s[1], s[2])
-		case 5:
-			continue
-		default:
-			t.Fatalf("Unexpected size sample: %d", len(s))
-		}
-
-		if expected != actual {
-			t.Fatalf("Expected %v, got %v for %dD sample at %v",
-				expected, actual, len(s)-1, s[:len(s)-1])
-		}
-	}
-}