github.com/matrixorigin/matrixone@v0.7.0/pkg/vectorize/ceil/ceil_test.go (about)

     1  // Copyright 2021 Matrix Origin
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //	http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  package ceil
    15  
    16  import (
    17  	"math"
    18  	"testing"
    19  
    20  	"github.com/stretchr/testify/assert"
    21  	"github.com/stretchr/testify/require"
    22  )
    23  
    24  func TestCeilUint8(t *testing.T) {
    25  	nums := []uint8{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 199, 233}
    26  	res := make([]uint8, len(nums))
    27  	res0 := ceilUint8(nums, res, 0)
    28  	correctRes0 := []uint8{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 199, 233}
    29  	for i := range res0 {
    30  		require.Equal(t, res0[i], correctRes0[i])
    31  	}
    32  	resMinus1 := ceilUint8(nums, res, -1)
    33  	correctResMinus1 := []uint8{10, 10, 10, 10, 10, 20, 30, 40, 60, 90, 150, 200, 240}
    34  	for i := range resMinus1 {
    35  		require.Equal(t, correctResMinus1[i], resMinus1[i])
    36  	}
    37  	resMinus2 := ceilUint8(nums, res, -2)
    38  	correctResMinus2 := []uint8{100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 200, 200, 0}
    39  	for i := range resMinus2 {
    40  		require.Equal(t, correctResMinus2[i], resMinus2[i])
    41  	}
    42  }
    43  func TestCeilUint16(t *testing.T) {
    44  	nums := []uint16{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368}
    45  	res := make([]uint16, len(nums))
    46  	res0 := CeilUint16(nums, res, 0)
    47  	correctRes0 := []uint16{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368}
    48  	for i := range res0 {
    49  		require.Equal(t, correctRes0[i], res0[i])
    50  	}
    51  	resMinus1 := CeilUint16(nums, res, -1)
    52  	correctResMinus1 := []uint16{10, 10, 10, 10, 10, 20, 30, 40, 60, 90, 150, 240, 380, 610, 990, 1600, 2590, 4190, 6770, 10950, 17720, 28660, 46370}
    53  	for i := range resMinus1 {
    54  		require.Equal(t, correctResMinus1[i], resMinus1[i])
    55  	}
    56  	resMinus2 := CeilUint16(nums, res, -2)
    57  	correctResMinus2 := []uint16{100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 200, 300, 400, 700, 1000, 1600, 2600, 4200, 6800, 11000, 17800, 28700, 46400}
    58  	for i := range resMinus2 {
    59  		require.Equal(t, correctResMinus2[i], resMinus2[i])
    60  	}
    61  }
    62  func TestCeilUint32(t *testing.T) {
    63  	nums := []uint32{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811}
    64  	res := make([]uint32, len(nums))
    65  	res0 := CeilUint32(nums, res, 0)
    66  	correctRes0 := []uint32{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811}
    67  	for i := range res0 {
    68  		require.Equal(t, res0[i], correctRes0[i])
    69  	}
    70  	resMinus1 := CeilUint32(nums, res, -1)
    71  	correctResMinus1 := []uint32{10, 10, 10, 10, 10, 20, 30, 40, 60, 90, 150, 240, 380, 610, 990, 1600, 2590, 4190, 6770, 10950, 17720, 28660, 46370, 75030, 121400, 196420, 317820}
    72  	for i := range res0 {
    73  		require.Equal(t, resMinus1[i], correctResMinus1[i])
    74  	}
    75  	resMinus2 := CeilUint32(nums, res, -2)
    76  
    77  	correctResMinus2 := []uint32{100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 200, 300, 400, 700, 1000, 1600, 2600, 4200, 6800, 11000, 17800, 28700, 46400, 75100, 121400, 196500, 317900}
    78  	for i := range res0 {
    79  		require.Equal(t, resMinus2[i], correctResMinus2[i])
    80  	}
    81  }
    82  
    83  func TestCeilUint64(t *testing.T) {
    84  	nums := []uint64{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811}
    85  	res := make([]uint64, len(nums))
    86  	res0 := CeilUint64(nums, res, 0)
    87  	correctRes0 := []uint64{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811}
    88  	for i := range res0 {
    89  		require.Equal(t, res0[i], correctRes0[i])
    90  	}
    91  	resMinus1 := CeilUint64(nums, res, -1)
    92  	correctResMinus1 := []uint64{10, 10, 10, 10, 10, 20, 30, 40, 60, 90, 150, 240, 380, 610, 990, 1600, 2590, 4190, 6770, 10950, 17720, 28660, 46370, 75030, 121400, 196420, 317820}
    93  	for i := range res0 {
    94  		require.Equal(t, resMinus1[i], correctResMinus1[i])
    95  	}
    96  	resMinus2 := CeilUint64(nums, res, -2)
    97  
    98  	correctResMinus2 := []uint64{100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 200, 300, 400, 700, 1000, 1600, 2600, 4200, 6800, 11000, 17800, 28700, 46400, 75100, 121400, 196500, 317900}
    99  	for i := range res0 {
   100  		require.Equal(t, resMinus2[i], correctResMinus2[i])
   101  	}
   102  }
   103  
   104  func TestCeilInt8(t *testing.T) {
   105  	nums := []int8{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, -1, -2, -3, -5, -8, -13, -21, -34, -55, -89}
   106  	res := make([]int8, len(nums))
   107  	res0 := CeilInt8(nums, res, 0)
   108  	correctRes0 := []int8{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, -1, -2, -3, -5, -8, -13, -21, -34, -55, -89}
   109  	for i := range res0 {
   110  		require.Equal(t, correctRes0[i], res0[i])
   111  	}
   112  	resMinus1 := CeilInt8(nums, res, -1)
   113  	correctResMinus1 := []int8{10, 10, 10, 10, 10, 20, 30, 40, 60, 90, 0, 0, 0, 0, 0, -10, -20, -30, -50, -80}
   114  	for i := range res0 {
   115  		require.Equal(t, correctResMinus1[i], resMinus1[i])
   116  	}
   117  }
   118  
   119  func TestCeilInt16(t *testing.T) {
   120  	nums := []int16{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, -1, -2, -3, -5, -8, -13, -21, -34, -55, -89, -144, -233, -377, -610, -987, -1597, -2584, -4181}
   121  	res := make([]int16, len(nums))
   122  	res0 := CeilInt16(nums, res, 0)
   123  	correctRes0 := []int16{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, -1, -2, -3, -5, -8, -13, -21, -34, -55, -89, -144, -233, -377, -610, -987, -1597, -2584, -4181}
   124  	for i := range res0 {
   125  		require.Equal(t, correctRes0[i], res0[i])
   126  	}
   127  	resMinus1 := CeilInt16(nums, res, -1)
   128  
   129  	correctResMinus1 := []int16{10, 10, 10, 10, 10, 20, 30, 40, 60, 90, 150, 240, 380, 610, 990, 1600, 2590, 4190, 0, 0, 0, 0, 0, -10, -20, -30, -50, -80, -140, -230, -370, -610, -980, -1590, -2580, -4180}
   130  	for i := range res0 {
   131  		require.Equal(t, correctResMinus1[i], resMinus1[i])
   132  	}
   133  }
   134  
   135  func TestCeilInt32(t *testing.T) {
   136  	nums := []int32{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, -1, -2, -3, -5, -8, -13, -21, -34, -55, -89, -144, -233, -377, -610, -987, -1597, -2584, -4181}
   137  	res := make([]int32, len(nums))
   138  	res0 := CeilInt32(nums, res, 0)
   139  	correctRes0 := []int32{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, -1, -2, -3, -5, -8, -13, -21, -34, -55, -89, -144, -233, -377, -610, -987, -1597, -2584, -4181}
   140  	for i := range res0 {
   141  		require.Equal(t, correctRes0[i], res0[i])
   142  	}
   143  	resMinus1 := CeilInt32(nums, res, -1)
   144  
   145  	correctResMinus1 := []int32{10, 10, 10, 10, 10, 20, 30, 40, 60, 90, 150, 240, 380, 610, 990, 1600, 2590, 4190, 0, 0, 0, 0, 0, -10, -20, -30, -50, -80, -140, -230, -370, -610, -980, -1590, -2580, -4180}
   146  	for i := range res0 {
   147  		require.Equal(t, correctResMinus1[i], resMinus1[i])
   148  	}
   149  }
   150  
   151  func TestCeilInt64(t *testing.T) {
   152  	nums := []int64{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, -1, -2, -3, -5, -8, -13, -21, -34, -55, -89, -144, -233, -377, -610, -987, -1597, -2584, -4181, 32768, 1234567}
   153  	res := make([]int64, len(nums))
   154  	res0 := CeilInt64(nums, res, 0)
   155  	correctRes0 := []int64{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, -1, -2, -3, -5, -8, -13, -21, -34, -55, -89, -144, -233, -377, -610, -987, -1597, -2584, -4181, 32768, 1234567}
   156  	for i := range res0 {
   157  		require.Equal(t, correctRes0[i], res0[i])
   158  	}
   159  	resMinus1 := CeilInt64(nums, res, -1)
   160  	correctResMinus1 := []int64{10, 10, 10, 10, 10, 20, 30, 40, 60, 90, 150, 240, 380, 610, 990, 1600, 2590, 4190, 0, 0, 0, 0, 0, -10, -20, -30, -50, -80, -140, -230, -370, -610, -980, -1590, -2580, -4180, 32770, 1234570}
   161  	for i := range resMinus1 {
   162  		require.Equal(t, correctResMinus1[i], resMinus1[i])
   163  	}
   164  }
   165  
   166  const tolerance = .00001
   167  
   168  func floatCompare(x, y float64) bool {
   169  	diff := math.Abs(x - y)
   170  	mean := math.Abs(x + y)
   171  	if math.IsNaN(diff / mean) {
   172  		return true
   173  	}
   174  	return (diff / mean) < tolerance
   175  }
   176  
   177  func TestCeilCeil32(t *testing.T) {
   178  	nums := []float32{1.5, -1.5, 2.5, -2.5, 1.2, 12.3, 123.4, 1234.5, 12345.6, 1234.567, -1.2, -12.3, -123.4, -1234.5, -12345.6}
   179  	res := make([]float32, len(nums))
   180  	res0 := ceilFloat32(nums, res, 0)
   181  	correctRes0 := []float32{2, -1, 3, -2, 2, 13, 124, 1235, 12346, 1235, -1, -12, -123, -1234, -12345}
   182  	for i := range nums {
   183  		assert.True(t, floatCompare(float64(correctRes0[i]), float64(res0[i])))
   184  	}
   185  	resMinus1 := ceilFloat32(nums, res, -1)
   186  	correctResMinus1 := []float32{10, 0, 10, 0, 10, 20, 130, 1240, 12350, 1240, 0, -10, -120, -1230, -12340}
   187  	for i := range nums {
   188  		assert.True(t, floatCompare(float64(correctResMinus1[i]), float64(resMinus1[i])))
   189  	}
   190  	res1 := ceilFloat32(nums, res, 1)
   191  	correctRes1 := []float32{1.5, -1.5, 2.5, -2.5, 1.2, 12.3, 123.4, 1234.5, 12345.6, 1234.6, -1.2, -12.3, -123.4, -1234.5, -12345.6}
   192  	for i := range res1 {
   193  		assert.True(t, floatCompare(float64(correctRes1[i]), float64(res1[i])))
   194  	}
   195  }
   196  
   197  func TestCeilFloat64(t *testing.T) {
   198  	nums := []float64{1.5, -1.5, 2.5, -2.5, 1.2, 12.3, 123.4, 1234.5, 12345.6, 1234.567, -1.2, -12.3, -123.4, -1234.5, -12345.6}
   199  	res := make([]float64, len(nums))
   200  	res0 := ceilFloat64(nums, res, 0)
   201  	correctRes0 := []float64{2, -1, 3, -2, 2, 13, 124, 1235, 12346, 1235, -1, -12, -123, -1234, -12345}
   202  	for i := range nums {
   203  		assert.True(t, floatCompare(correctRes0[i], res0[i]))
   204  	}
   205  	resMinus1 := ceilFloat64(nums, res, -1)
   206  	correctResMinus1 := []float64{10, 0, 10, 0, 10, 20, 130, 1240, 12350, 1240, 0, -10, -120, -1230, -12340}
   207  	for i := range nums {
   208  		assert.True(t, floatCompare(correctResMinus1[i], resMinus1[i]))
   209  	}
   210  	res1 := ceilFloat64(nums, res, 1)
   211  	correctRes1 := []float64{1.5, -1.5, 2.5, -2.5, 1.2, 12.3, 123.4, 1234.5, 12345.6, 1234.6, -1.2, -12.3, -123.4, -1234.5, -12345.6}
   212  	for i := range res1 {
   213  		assert.True(t, floatCompare(correctRes1[i], res1[i]))
   214  	}
   215  }