Merge pull request #8 from Eclalang/7-update-funcs-sort-and-max-min

7 update funcs sort and max min

Author: Axou89

README.md

@@ -7,12 +7,17 @@
 
 | Func Name |                              Prototype                              |                                          Description                                          | Comments |
 |:---------:|:-------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------:|:--------:|
-|  Contain  |       func Contain[T comparable](array []T, value T) bool {}        |                               Test if the value is in the array                               |   N/A    |
+| Contains  |       func Contain[T comparable](array []T, value T) bool {}        |                               Test if the value is in the array                               |   N/A    |
 |   Find    |         func Find[T comparable](array []T, value T) int {}          | Returns the index of the value in the array <br/> (return -1 if the value isn't in the array) |   N/A    |
 |  IsEqual  |   func IsEqual[T comparable](FirstArray, SecondArray []T) bool {}   |                          Test two array and check if they are equals                          |   N/A    |
 |    Max    |         func Max[T cmp.Ordered](array []T) (any, error) {}          |                            Returns the maximum value in the array                             |   N/A    |
 |    Min    |         func Min[T cmp.Ordered](array []T) (any, error) {}          |                            Returns the minimum value in the array                             |   N/A    |
 |  Remove   |       func Remove[T comparable](array []T, index int) []T {}        |                          Removes the value of the array at the index                          |   N/A    |
 |   Slice   | func Slice[T comparable](array []T, start, end int) ([]T, error) {} |                              Slices the array from start to end                               |   N/A    |
-|  SortAsc  |              func SortAsc[T cmp.Ordered](array []T) {}              |                              Sorts the array in ascending order                               |   N/A    |
-| SortDesc  |             func SortDesc[T cmp.Ordered](array []T) {}              |                              Sorts the array in descending order                              |   N/A    |
+|   Sort    |          func Sort[T cmp.Ordered](array []T, order int) {}          |                       Sorts the array in ascending or descending order                        |   N/A    |
+
+## Constants :
+| Name | Type | Value |
+|:----:|:----:|:-----:|
+| ASC  | int  |   0   |
+| DESC | int  |   1   |

array.go

@@ -3,12 +3,18 @@ package array
 import (
 	"cmp"
 	"errors"
+	"github.com/Eclalang/Ecla/interpreter/eclaType"
 	"reflect"
 	"sort"
 )
 
-// Contain test if the value is in the array return True if inside and False if not inside
-func Contain[T comparable](array []T, value T) bool {
+var Variables = map[string]eclaType.Type{
+	"ASC":  eclaType.Int(0),
+	"DESC": eclaType.Int(1),
+}
+
+// Contains test if the value is in the array return True if inside and False if not inside
+func Contains[T comparable](array []T, value T) bool {
 	size := len(array)
 	for i := 0; i < size; i++ {
 		if reflect.DeepEqual(array[i], value) {
@@ -49,10 +55,18 @@ func Max[T cmp.Ordered](array []T) (any, error) {
 		return nil, errors.New("empty array")
 	}
 	m := array[0]
-	for i := 1; i < size; i++ {
-		if m < array[i] {
-			m = array[i]
+	if reflect.TypeOf(m).Kind() == reflect.String {
+		for i := 1; i < size; i++ {
+			if len(any(m).(string)) < len(any(array[i]).(string)) {
+				m = array[i]
+			} else if len(any(m).(string)) == len(any(array[i]).(string)) {
+				m = max(m, array[i])
+			}
 		}
+		return m, nil
+	}
+	for i := 1; i < size; i++ {
+		m = max(m, array[i])
 	}
 	return m, nil
 }
@@ -64,10 +78,19 @@ func Min[T cmp.Ordered](array []T) (any, error) {
 		return nil, errors.New("empty array")
 	}
 	m := array[0]
-	for i := 1; i < size; i++ {
-		if array[i] < m {
-			m = array[i]
+	if reflect.TypeOf(m).Kind() == reflect.String {
+		for i := 1; i < size; i++ {
+			if len(any(m).(string)) > len(any(array[i]).(string)) {
+				m = array[i]
+			} else if len(any(m).(string)) == len(any(array[i]).(string)) {
+				m = min(m, array[i])
+			}
 		}
+		return m, nil
+	}
+
+	for i := 1; i < size; i++ {
+		m = min(m, array[i])
 	}
 	return m, nil
 }
@@ -99,16 +122,15 @@ func Slice[T comparable](array []T, start, end int) ([]T, error) {
 	return arrRet, nil
 }
 
-// SortAsc sorts the array in ascending order
-func SortAsc[T cmp.Ordered](array []T) {
-	sort.Slice(array, func(i, j int) bool {
-		return array[i] < array[j]
-	})
-}
-
-// SortDesc sorts the array in descending order
-func SortDesc[T cmp.Ordered](array []T) {
-	sort.Slice(array, func(i, j int) bool {
-		return array[i] > array[j]
-	})
+// Sort sorts the array in ascending or descending order
+func Sort[T cmp.Ordered](array []T, order int) {
+	if order == 0 {
+		sort.Slice(array, func(i, j int) bool {
+			return array[i] < array[j]
+		})
+	} else {
+		sort.Slice(array, func(i, j int) bool {
+			return array[i] > array[j]
+		})
+	}
 }

array_test.go

@@ -7,33 +7,33 @@ import (
 )
 
 // TestContain test the function Contain with array of type int, float, string and boolean
-func TestContain(t *testing.T) {
+func TestContains(t *testing.T) {
 	arr := []any{1, 2, 3.3, 4.4, "five", "six", true, false}
 
 	// Test int
-	check1 := Contain(arr, 1)
-	check2 := Contain(arr, 2)
-	check3 := Contain(arr, 3)
+	check1 := Contains(arr, 1)
+	check2 := Contains(arr, 2)
+	check3 := Contains(arr, 3)
 	if check1 == true && check2 == true && check3 == false {
 		fmt.Println("Yes (1/4) | Array Find is set successfully for int")
 	} else {
 		t.Error("No (1/4) | Array Find isn't set successfully for int")
 	}
 
 	// Test float
-	check1 = Contain(arr, 3.3)
-	check2 = Contain(arr, 4.4)
-	check3 = Contain(arr, 5.5)
+	check1 = Contains(arr, 3.3)
+	check2 = Contains(arr, 4.4)
+	check3 = Contains(arr, 5.5)
 	if check1 == true && check2 == true && check3 == false {
 		fmt.Println("Yes (2/4) | Array Find is set successfully for float64")
 	} else {
 		t.Error("No (2/4) | Array Find isn't set successfully for float64")
 	}
 
 	// Test string
-	check1 = Contain(arr, "five")
-	check2 = Contain(arr, "six")
-	check3 = Contain(arr, "seven")
+	check1 = Contains(arr, "five")
+	check2 = Contains(arr, "six")
+	check3 = Contains(arr, "seven")
 
 	if check1 == true && check2 == true && check3 == false {
 		fmt.Println("Yes (3/4) | Array Find is set successfully for string")
@@ -42,8 +42,8 @@ func TestContain(t *testing.T) {
 	}
 
 	// Test boolean
-	check1 = Contain(arr, true)
-	check2 = Contain(arr, false)
+	check1 = Contains(arr, true)
+	check2 = Contains(arr, false)
 	if check1 == true && check2 == true {
 		fmt.Println("Yes (4/4) | Array Find is set successfully for boolean")
 	} else {
@@ -127,7 +127,7 @@ func TestIsEqual(t *testing.T) {
 func TestMax(t *testing.T) {
 	arrInt := []int{1, 20, 300, 44, 56}
 	arrFloat := []float64{100.1, 20.2, 3.346598, 458.9, 5.5}
-	arrString := []string{"one", "two", "three", "four", "five"}
+	arrString := []string{"one", "two", "three", "fours", "five"}
 	var arrEmpty []int
 
 	// Test int
@@ -148,7 +148,7 @@ func TestMax(t *testing.T) {
 
 	// Test string
 	stringMax, _ := Max(arrString)
-	if stringMax == "two" {
+	if stringMax == "three" {
 		fmt.Println("Yes (3/4) | Array Max is set successfully for string")
 	} else {
 		t.Error("No (3/4) | Array Max isn't set successfully for string")
@@ -167,7 +167,7 @@ func TestMax(t *testing.T) {
 func TestMin(t *testing.T) {
 	arrInt := []int{1, 20, 300, 44, 56}
 	arrFloat := []float64{100.1, 20.2, 3.346598, 458.9, 5.5}
-	arrString := []string{"one", "two", "three", "four", "five"}
+	arrString := []string{"zero", "one", "two", "three", "four", "five"}
 	var arrEmpty []int
 
 	// Test int
@@ -188,7 +188,7 @@ func TestMin(t *testing.T) {
 
 	// Test string
 	stringMin, _ := Min(arrString)
-	if stringMin == "five" {
+	if stringMin == "one" {
 		fmt.Println("Yes (3/4) | Array Min is set successfully for string")
 	} else {
 		t.Error("No (3/4) | Array Min isn't set successfully for string")
@@ -336,70 +336,73 @@ func TestSlice(t *testing.T) {
 	}
 }
 
-// TestSortAsc test the function SortAsc with array of type int, float64 and string
-func TestSortAsc(t *testing.T) {
+// TestSort test the function Sort with array of type int, float64 and string
+func TestSort(t *testing.T) {
 	arrInt := []int{3, 6, 9, 2, 5, 8, 0, 1, 4, 7}
-	arrIntExpected := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+	arrIntExpectedAscending := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
+	arrIntExpectedDescending := []int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
 	arrFloat := []float64{3.3, 6.6, 9.9, 2.2, 5.5, 8.8, 0.0, 1.1, 4.4, 7.7}
-	arrFloatExpected := []float64{0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9}
+	arrFloatExpectedAscending := []float64{0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9}
+	arrFloatExpectedDescending := []float64{9.9, 8.8, 7.7, 6.6, 5.5, 4.4, 3.3, 2.2, 1.1, 0.0}
 	arrString := []string{"a", "ccc", "bb", "eeeee", "dddd"}
-	arrStringExpected := []string{"a", "bb", "ccc", "dddd", "eeeee"}
+	arrStringExpectedAscending := []string{"a", "bb", "ccc", "dddd", "eeeee"}
+	arrStringExpectedDescending := []string{"eeeee", "dddd", "ccc", "bb", "a"}
 
-	SortAsc(arrInt)
-	SortAsc(arrFloat)
-	SortAsc(arrString)
+	// Test ascending order
+	Sort(arrInt, 0)
+	Sort(arrFloat, 0)
+	Sort(arrString, 0)
 
 	// Test array int
-	equal := IsEqual(arrInt, arrIntExpected)
+	equal := IsEqual(arrInt, arrIntExpectedAscending)
 	if equal {
-		fmt.Println("Yes (1/3) | Array SortAsc is set successfully for int")
+		fmt.Println("Yes (1/6) | Array Sort is set successfully for int in ascending order")
 	} else {
-		t.Error("No (1/3) | Array SortAsc isn't set successfully for int")
+		t.Error("No (1/6) | Array SortAsc isn't set successfully for int in ascending order")
 	}
 
 	// Test array float64
-	equal = IsEqual(arrFloat, arrFloatExpected)
+	equal = IsEqual(arrFloat, arrFloatExpectedAscending)
 	if equal {
-		fmt.Println("Yes (2/3) | Array SortAsc is set successfully for float64")
+		fmt.Println("Yes (2/6) | Array SortAsc is set successfully for float64 in ascending order")
 	} else {
-		t.Error("No (2/3) | Array SortAsc isn't set successfully for float64")
+		t.Error("No (2/6) | Array SortAsc isn't set successfully for float64 in ascending order")
 	}
 
 	// Test array string
-	equal = IsEqual(arrString, arrStringExpected)
+	equal = IsEqual(arrString, arrStringExpectedAscending)
 	if equal {
-		fmt.Println("Yes (3/3) | Array SortAsc is set successfully for string")
+		fmt.Println("Yes (3/6) | Array SortAsc is set successfully for string in ascending order")
 	} else {
-		t.Error("No (3/3) | Array SortAsc isn't set successfully for string")
+		t.Error("No (3/6) | Array SortAsc isn't set successfully for string in ascending order")
 	}
-}
-
-// TestSortDesc test the function SortAsc with array of type int, float64 and string
-func TestSortDesc(t *testing.T) {
-	arrInt := []int{3, 6, 9, 2, 5, 8, 0, 1, 4, 7}
-	arrIntExpected := []int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
-	arrFloat := []float64{3.3, 6.6, 9.9, 2.2, 5.5, 8.8, 0.0, 1.1, 4.4, 7.7}
-	arrFloatExpected := []float64{9.9, 8.8, 7.7, 6.6, 5.5, 4.4, 3.3, 2.2, 1.1, 0.0}
-	arrString := []string{"a", "ccc", "bb", "eeeee", "dddd"}
-	arrStringExpected := []string{"eeeee", "dddd", "ccc", "bb", "a"}
 
-	SortDesc(arrInt)
-	SortDesc(arrFloat)
-	SortDesc(arrString)
+	// Test descending order
+	Sort(arrInt, 1)
+	Sort(arrFloat, 1)
+	Sort(arrString, 1)
 
-	if IsEqual(arrInt, arrIntExpected) {
-		fmt.Println("Yes (1/3) | Array SortDesc is set successfully for int")
+	// Test array int
+	equal = IsEqual(arrInt, arrIntExpectedDescending)
+	if equal {
+		fmt.Println("Yes (4/6) | Array Sort is set successfully for int in descending order")
 	} else {
-		t.Error("No (1/3) | Array SortDesc isn't set successfully for int")
+		t.Error("No (4/6) | Array Sort isn't set successfully for int in descending order")
 	}
-	if IsEqual(arrFloat, arrFloatExpected) {
-		fmt.Println("Yes (2/3) | Array SortDesc is set successfully for float64")
+
+	// Test array float64
+	equal = IsEqual(arrFloat, arrFloatExpectedDescending)
+	if equal {
+		fmt.Println("Yes (5/6) | Array Sort is set successfully for float64 in descending order")
 	} else {
-		t.Error("No (2/3) | Array SortDesc isn't set successfully for float64")
+		t.Error("No (5/6) | Array Sort isn't set successfully for float64 in descending order")
 	}
-	if IsEqual(arrString, arrStringExpected) {
-		fmt.Println("Yes (3/3) | Array SortDesc is set successfully for string")
+
+	// Test array string
+	equal = IsEqual(arrString, arrStringExpectedDescending)
+	if equal {
+		fmt.Println("Yes (6/6) | Array Sort is set successfully for string in descending order")
 	} else {
-		t.Error("No (3/3) | Array SortDesc isn't set successfully for string")
+		t.Error("No (6/6) | Array Sort isn't set successfully for string in descending order")
 	}
 }

go.mod

@@ -1,3 +1,5 @@
 module github.com/Eclalang/array
 
 go 1.21.1
+
+require github.com/Eclalang/Ecla v1.0.0

go.sum

@@ -0,0 +1,2 @@
+github.com/Eclalang/Ecla v1.0.0 h1:JrbxU5m6hWfJ8D5/xsqtbhWljOOetDdV6JzEU82/4Fc=
+github.com/Eclalang/Ecla v1.0.0/go.mod h1:0Nq24TRfBRBY5oKK+U2hpdzQV0rlisPQZ5nhBLNGxAU=