pkg.re/essentialkaos/ek.10@v12.41.0+incompatible/mathutil/mathutil.go (about) 1 // Package mathutil provides some additional math methods 2 package mathutil 3 4 // ////////////////////////////////////////////////////////////////////////////////// // 5 // // 6 // Copyright (c) 2022 ESSENTIAL KAOS // 7 // Apache License, Version 2.0 <https://www.apache.org/licenses/LICENSE-2.0> // 8 // // 9 // ////////////////////////////////////////////////////////////////////////////////// // 10 11 import ( 12 "math" 13 ) 14 15 // ////////////////////////////////////////////////////////////////////////////////// // 16 17 // Between returns value between min and max values 18 func Between(val, min, max int) int { 19 switch { 20 case val < min: 21 return min 22 case val > max: 23 return max 24 default: 25 return val 26 } 27 } 28 29 // Min returns a smaller value 30 func Min(val1, val2 int) int { 31 if val1 < val2 { 32 return val1 33 } 34 35 return val2 36 } 37 38 // Max returns a greater value 39 func Max(val1, val2 int) int { 40 if val1 > val2 { 41 return val1 42 } 43 44 return val2 45 } 46 47 // BetweenU returns value between min and max values 48 func BetweenU(val, min, max uint) uint { 49 switch { 50 case val < min: 51 return min 52 case val > max: 53 return max 54 default: 55 return val 56 } 57 } 58 59 // MinU returns a smaller value 60 func MinU(val1, val2 uint) uint { 61 if val1 < val2 { 62 return val1 63 } 64 65 return val2 66 } 67 68 // MaxU returns a greater value 69 func MaxU(val1, val2 uint) uint { 70 if val1 > val2 { 71 return val1 72 } 73 74 return val2 75 } 76 77 // Between8 returns value between min and max values 78 func Between8(val, min, max int8) int8 { 79 switch { 80 case val < min: 81 return min 82 case val > max: 83 return max 84 default: 85 return val 86 } 87 } 88 89 // Min8 returns a smaller value 90 func Min8(val1, val2 int8) int8 { 91 if val1 < val2 { 92 return val1 93 } 94 95 return val2 96 } 97 98 // Max8 returns a greater value 99 func Max8(val1, val2 int8) int8 { 100 if val1 > val2 { 101 return val1 102 } 103 104 return val2 105 } 106 107 // Between16 returns value between min and max values 108 func Between16(val, min, max int16) int16 { 109 switch { 110 case val < min: 111 return min 112 case val > max: 113 return max 114 default: 115 return val 116 } 117 } 118 119 // Min16 returns a smaller value 120 func Min16(val1, val2 int16) int16 { 121 if val1 < val2 { 122 return val1 123 } 124 125 return val2 126 } 127 128 // Max16 returns a greater value 129 func Max16(val1, val2 int16) int16 { 130 if val1 > val2 { 131 return val1 132 } 133 134 return val2 135 } 136 137 // Between32 returns value between min and max values 138 func Between32(val, min, max int32) int32 { 139 switch { 140 case val < min: 141 return min 142 case val > max: 143 return max 144 default: 145 return val 146 } 147 } 148 149 // Min32 returns a smaller value 150 func Min32(val1, val2 int32) int32 { 151 if val1 < val2 { 152 return val1 153 } 154 155 return val2 156 } 157 158 // Max32 returns a greater value 159 func Max32(val1, val2 int32) int32 { 160 if val1 > val2 { 161 return val1 162 } 163 164 return val2 165 } 166 167 // Between64 returns value between min and max values 168 func Between64(val, min, max int64) int64 { 169 switch { 170 case val < min: 171 return min 172 case val > max: 173 return max 174 default: 175 return val 176 } 177 } 178 179 // Min64 returns a smaller value 180 func Min64(val1, val2 int64) int64 { 181 if val1 < val2 { 182 return val1 183 } 184 185 return val2 186 } 187 188 // Max64 returns a greater value 189 func Max64(val1, val2 int64) int64 { 190 if val1 > val2 { 191 return val1 192 } 193 194 return val2 195 } 196 197 // BetweenU8 returns value between min and max values 198 func BetweenU8(val, min, max uint8) uint8 { 199 switch { 200 case val < min: 201 return min 202 case val > max: 203 return max 204 default: 205 return val 206 } 207 } 208 209 // MinU8 returns a smaller value 210 func MinU8(val1, val2 uint8) uint8 { 211 if val1 < val2 { 212 return val1 213 } 214 215 return val2 216 } 217 218 // MaxU8 returns a greater value 219 func MaxU8(val1, val2 uint8) uint8 { 220 if val1 > val2 { 221 return val1 222 } 223 224 return val2 225 } 226 227 // BetweenU16 returns value between min and max values 228 func BetweenU16(val, min, max uint16) uint16 { 229 switch { 230 case val < min: 231 return min 232 case val > max: 233 return max 234 default: 235 return val 236 } 237 } 238 239 // MinU16 returns a smaller value 240 func MinU16(val1, val2 uint16) uint16 { 241 if val1 < val2 { 242 return val1 243 } 244 245 return val2 246 } 247 248 // MaxU16 returns a greater value 249 func MaxU16(val1, val2 uint16) uint16 { 250 if val1 > val2 { 251 return val1 252 } 253 254 return val2 255 } 256 257 // BetweenU32 returns value between min and max values 258 func BetweenU32(val, min, max uint32) uint32 { 259 switch { 260 case val < min: 261 return min 262 case val > max: 263 return max 264 default: 265 return val 266 } 267 } 268 269 // MinU32 returns a smaller value 270 func MinU32(val1, val2 uint32) uint32 { 271 if val1 < val2 { 272 return val1 273 } 274 275 return val2 276 } 277 278 // MaxU32 returns a greater value 279 func MaxU32(val1, val2 uint32) uint32 { 280 if val1 > val2 { 281 return val1 282 } 283 284 return val2 285 } 286 287 // BetweenU64 returns value between min and max values 288 func BetweenU64(val, min, max uint64) uint64 { 289 switch { 290 case val < min: 291 return min 292 case val > max: 293 return max 294 default: 295 return val 296 } 297 } 298 299 // MinU64 returns a smaller value 300 func MinU64(val1, val2 uint64) uint64 { 301 if val1 < val2 { 302 return val1 303 } 304 305 return val2 306 } 307 308 // MaxU64 returns a greater value 309 func MaxU64(val1, val2 uint64) uint64 { 310 if val1 > val2 { 311 return val1 312 } 313 314 return val2 315 } 316 317 // BetweenF returns value between min and max values 318 func BetweenF(val, min, max float64) float64 { 319 return BetweenF64(val, min, max) 320 } 321 322 // BetweenF32 returns value between min and max values 323 func BetweenF32(val, min, max float32) float32 { 324 switch { 325 case val < min: 326 return min 327 case val > max: 328 return max 329 default: 330 return val 331 } 332 } 333 334 // BetweenF64 returns value between min and max values 335 func BetweenF64(val, min, max float64) float64 { 336 switch { 337 case val < min: 338 return min 339 case val > max: 340 return max 341 default: 342 return val 343 } 344 } 345 346 // Abs returns absolute value 347 func Abs(val int) int { 348 if val < 0 { 349 return val * -1 350 } 351 352 return val 353 } 354 355 // Abs8 returns absolute value 356 func Abs8(val int8) int8 { 357 if val < 0 { 358 return val * -1 359 } 360 361 return val 362 } 363 364 // Abs16 returns absolute value 365 func Abs16(val int16) int16 { 366 if val < 0 { 367 return val * -1 368 } 369 370 return val 371 } 372 373 // Abs32 returns absolute value 374 func Abs32(val int32) int32 { 375 if val < 0 { 376 return val * -1 377 } 378 379 return val 380 } 381 382 // Abs64 returns absolute value 383 func Abs64(val int64) int64 { 384 if val < 0 { 385 return val * -1 386 } 387 388 return val 389 } 390 391 // AbsF returns absolute value 392 func AbsF(val float64) float64 { 393 return AbsF64(val) 394 } 395 396 // AbsF32 returns absolute value 397 func AbsF32(val float32) float32 { 398 if val < 0 { 399 return val * -1 400 } 401 402 return val 403 } 404 405 // AbsF64 returns absolute value 406 func AbsF64(val float64) float64 { 407 if val < 0 { 408 return val * -1 409 } 410 411 return val 412 } 413 414 // Round returns rounded value 415 func Round(v float64, p int) float64 { 416 pow := math.Pow(10, float64(p)) 417 digit := pow * v 418 _, div := math.Modf(digit) 419 420 if div >= 0.5 { 421 return math.Ceil(digit) / pow 422 } 423 424 return math.Floor(digit) / pow 425 } 426 427 // ////////////////////////////////////////////////////////////////////////////////// //