github.com/parquet-go/parquet-go@v0.21.1-0.20240501160520-b3c3a0c3ed6f/order_purego.go (about)

     1  //go:build purego || !amd64
     2  
     3  package parquet
     4  
     5  // -----------------------------------------------------------------------------
     6  // TODO: use generics versions of the these functions to reduce the amount of
     7  // code to maintain when we drop compatilibty with Go version older than 1.18.
     8  // -----------------------------------------------------------------------------
     9  
    10  func orderOfInt32(data []int32) int {
    11  	if len(data) > 1 {
    12  		if int32AreInAscendingOrder(data) {
    13  			return +1
    14  		}
    15  		if int32AreInDescendingOrder(data) {
    16  			return -1
    17  		}
    18  	}
    19  	return 0
    20  }
    21  
    22  func orderOfInt64(data []int64) int {
    23  	if len(data) > 1 {
    24  		if int64AreInAscendingOrder(data) {
    25  			return +1
    26  		}
    27  		if int64AreInDescendingOrder(data) {
    28  			return -1
    29  		}
    30  	}
    31  	return 0
    32  }
    33  
    34  func orderOfUint32(data []uint32) int {
    35  	if len(data) > 1 {
    36  		if uint32AreInAscendingOrder(data) {
    37  			return +1
    38  		}
    39  		if uint32AreInDescendingOrder(data) {
    40  			return -1
    41  		}
    42  	}
    43  	return 0
    44  }
    45  
    46  func orderOfUint64(data []uint64) int {
    47  	if len(data) > 1 {
    48  		if uint64AreInAscendingOrder(data) {
    49  			return +1
    50  		}
    51  		if uint64AreInDescendingOrder(data) {
    52  			return -1
    53  		}
    54  	}
    55  	return 0
    56  }
    57  
    58  func orderOfFloat32(data []float32) int {
    59  	if len(data) > 1 {
    60  		if float32AreInAscendingOrder(data) {
    61  			return +1
    62  		}
    63  		if float32AreInDescendingOrder(data) {
    64  			return -1
    65  		}
    66  	}
    67  	return 0
    68  }
    69  
    70  func orderOfFloat64(data []float64) int {
    71  	if len(data) > 1 {
    72  		if float64AreInAscendingOrder(data) {
    73  			return +1
    74  		}
    75  		if float64AreInDescendingOrder(data) {
    76  			return -1
    77  		}
    78  	}
    79  	return 0
    80  }
    81  
    82  func int32AreInAscendingOrder(data []int32) bool {
    83  	for i := len(data) - 1; i > 0; i-- {
    84  		if data[i-1] > data[i] {
    85  			return false
    86  		}
    87  	}
    88  	return true
    89  }
    90  
    91  func int32AreInDescendingOrder(data []int32) bool {
    92  	for i := len(data) - 1; i > 0; i-- {
    93  		if data[i-1] < data[i] {
    94  			return false
    95  		}
    96  	}
    97  	return true
    98  }
    99  
   100  func int64AreInAscendingOrder(data []int64) bool {
   101  	for i := len(data) - 1; i > 0; i-- {
   102  		if data[i-1] > data[i] {
   103  			return false
   104  		}
   105  	}
   106  	return true
   107  }
   108  
   109  func int64AreInDescendingOrder(data []int64) bool {
   110  	for i := len(data) - 1; i > 0; i-- {
   111  		if data[i-1] < data[i] {
   112  			return false
   113  		}
   114  	}
   115  	return true
   116  }
   117  
   118  func uint32AreInAscendingOrder(data []uint32) bool {
   119  	for i := len(data) - 1; i > 0; i-- {
   120  		if data[i-1] > data[i] {
   121  			return false
   122  		}
   123  	}
   124  	return true
   125  }
   126  
   127  func uint32AreInDescendingOrder(data []uint32) bool {
   128  	for i := len(data) - 1; i > 0; i-- {
   129  		if data[i-1] < data[i] {
   130  			return false
   131  		}
   132  	}
   133  	return true
   134  }
   135  
   136  func uint64AreInAscendingOrder(data []uint64) bool {
   137  	for i := len(data) - 1; i > 0; i-- {
   138  		if data[i-1] > data[i] {
   139  			return false
   140  		}
   141  	}
   142  	return true
   143  }
   144  
   145  func uint64AreInDescendingOrder(data []uint64) bool {
   146  	for i := len(data) - 1; i > 0; i-- {
   147  		if data[i-1] < data[i] {
   148  			return false
   149  		}
   150  	}
   151  	return true
   152  }
   153  
   154  func float32AreInAscendingOrder(data []float32) bool {
   155  	for i := len(data) - 1; i > 0; i-- {
   156  		if data[i-1] > data[i] {
   157  			return false
   158  		}
   159  	}
   160  	return true
   161  }
   162  
   163  func float32AreInDescendingOrder(data []float32) bool {
   164  	for i := len(data) - 1; i > 0; i-- {
   165  		if data[i-1] < data[i] {
   166  			return false
   167  		}
   168  	}
   169  	return true
   170  }
   171  
   172  func float64AreInAscendingOrder(data []float64) bool {
   173  	for i := len(data) - 1; i > 0; i-- {
   174  		if data[i-1] > data[i] {
   175  			return false
   176  		}
   177  	}
   178  	return true
   179  }
   180  
   181  func float64AreInDescendingOrder(data []float64) bool {
   182  	for i := len(data) - 1; i > 0; i-- {
   183  		if data[i-1] < data[i] {
   184  			return false
   185  		}
   186  	}
   187  	return true
   188  }