...
Tawesoft Logo

Source file src/tawesoft.co.uk/go/operator/float32.go

Documentation: src/tawesoft.co.uk/go/operator/float32.go

     1  package operator
     2  
     3  // Code generated by (tawesoft.co.uk/go/operator) template-numbers.py: DO NOT EDIT.
     4  
     5  import "math"
     6  
     7  // Some overflow checks with reference to stackoverflow.com/a/1514309/5654201
     8  
     9  type float32Unary struct {
    10      Identity        func(float32) float32
    11      Abs             func(float32) float32
    12      Negation        func(float32) float32
    13      Zero            func(float32) bool
    14      NonZero         func(float32) bool
    15      Positive        func(float32) bool
    16      Negative        func(float32) bool
    17  }
    18  
    19  type float32UnaryChecked struct {
    20      Abs             func(float32) (float32, error)
    21      Negation        func(float32) (float32, error)
    22  }
    23  
    24  type float32Binary struct {
    25      Add             func(float32, float32) float32
    26      Sub             func(float32, float32) float32
    27      Mul             func(float32, float32) float32
    28      Div             func(float32, float32) float32
    29      Mod             func(float32, float32) float32
    30      
    31      Eq              func(float32, float32) bool
    32      Neq             func(float32, float32) bool
    33      Lt              func(float32, float32) bool
    34      Lte             func(float32, float32) bool
    35      Gt              func(float32, float32) bool
    36      Gte             func(float32, float32) bool
    37      
    38      
    39  }
    40  
    41  type float32BinaryChecked struct {
    42      Add             func(float32, float32) (float32, error)
    43      Sub             func(float32, float32) (float32, error)
    44      Mul             func(float32, float32) (float32, error)
    45      Div             func(float32, float32) (float32, error)
    46      
    47  }
    48  
    49  type float32Nary struct {
    50      Add             func(... float32) float32
    51      Sub             func(... float32) float32
    52      Mul             func(... float32) float32
    53  }
    54  
    55  type float32NaryChecked struct {
    56      Add             func(... float32) (float32, error)
    57      Sub             func(... float32) (float32, error)
    58      Mul             func(... float32) (float32, error)
    59  }
    60  
    61  // Float32 implements operations on one (unary), two (binary), or many (nary) arguments of type float32.
    62  var Float32 = struct {
    63      Unary           float32Unary
    64      Binary          float32Binary
    65      Nary            float32Nary
    66      Reduce          func(operatorIdentity float32, operator func(float32, float32) float32, elements ... float32) float32
    67  }{
    68      Unary:          float32Unary{
    69          Identity:   func(a float32) float32 { return a },
    70          Abs:        float32UnaryAbs,
    71          Negation:   func(a float32) float32 { return -a },
    72          Zero:       func(a float32) bool { return a == 0 },
    73          NonZero:    func(a float32) bool { return a != 0 },
    74          Positive:   float32UnaryPositive,
    75          Negative:   float32UnaryNegative,
    76      },
    77      
    78      Binary:          float32Binary{
    79          Add:        func(a float32, b float32) float32 { return a + b },
    80          Sub:        func(a float32, b float32) float32 { return a - b },
    81          Mul:        func(a float32, b float32) float32 { return a * b },
    82          Div:        func(a float32, b float32) float32 { return a / b },
    83          
    84          Eq:         func(a float32, b float32) bool { return a == b },
    85          Neq:        func(a float32, b float32) bool { return a != b },
    86          Lt:         func(a float32, b float32) bool { return a <  b },
    87          Lte:        func(a float32, b float32) bool { return a <= b },
    88          Gt:         func(a float32, b float32) bool { return a >  b },
    89          Gte:        func(a float32, b float32) bool { return a >= b },
    90          
    91          
    92      },
    93      
    94      Nary:           float32Nary{
    95          Add:        float32NaryAdd,
    96          Mul:        float32NaryMul,
    97      },
    98      
    99      Reduce:         float32Reduce,
   100  }
   101  
   102  // Float32Checked implements operations on one (unary), two (binary), or many (nary) arguments of type float32, returning an
   103  // error in cases such as overflow or an undefined operation.
   104  var Float32Checked = struct {
   105      Unary           float32UnaryChecked
   106      Binary          float32BinaryChecked
   107      Nary            float32NaryChecked
   108      Reduce          func(operatorIdentity float32, operator func(float32, float32) (float32, error), elements ... float32) (float32, error)
   109  }{
   110      Unary:          float32UnaryChecked{
   111          Abs:        float32UnaryCheckedAbs,
   112          Negation:   float32UnaryCheckedNegation,
   113      },
   114      
   115      Binary:         float32BinaryChecked{
   116          Add:        float32BinaryCheckedAdd,
   117          Sub:        float32BinaryCheckedSub,
   118          Mul:        float32BinaryCheckedMul,
   119          Div:        float32BinaryCheckedDiv,
   120      },
   121      
   122      Nary:           float32NaryChecked{
   123          Add:        float32NaryCheckedAdd,
   124          Mul:        float32NaryCheckedMul,
   125      },
   126      
   127      Reduce:         float32CheckedReduce,
   128  }
   129  
   130  func float32UnaryPositive(a float32) bool {
   131      return math.Signbit(float64(a)) == false
   132  }
   133  
   134  func float32UnaryNegative(a float32) bool {
   135      return math.Signbit(float64(a)) == true
   136  }
   137  
   138  func float32UnaryAbs(a float32) float32 {
   139      return float32(math.Abs(float64(a)))
   140  }
   141  
   142  // note abs(+/- Inf) = +Inf
   143  func float32UnaryCheckedAbs(a float32) (v float32, err error) {
   144      if math.IsNaN(float64(a)) { return v, ErrorNaN }
   145      return float32(math.Abs(float64(a))), nil
   146  }
   147  
   148  func float32UnaryCheckedNegation(a float32) (v float32, err error) {
   149      if math.IsNaN(float64(a)) { return v, ErrorNaN }
   150      return -a, nil
   151  }
   152  
   153  func float32BinaryCheckedAdd(a float32, b float32) (v float32, err error) {
   154      if (b > 0) && (a > (maxFloat32 - b)) { return v, ErrorOverflow }
   155      if (b < 0) && (a < (minFloat32 - b)) { return v, ErrorOverflow }
   156      return a + b, nil
   157  }
   158  
   159  func float32BinaryCheckedSub(a float32, b float32) (v float32, err error) {
   160      if (b < 0) && (a > (maxFloat32 + b)) { return v, ErrorOverflow }
   161      if (b > 0) && (a < (minFloat32 + b)) { return v, ErrorOverflow }
   162      return a - b, nil
   163  }
   164  
   165  func float32BinaryCheckedMul(a float32, b float32) (v float32, err error) {
   166      if (a > (maxFloat32 / b)) { return v, ErrorOverflow }
   167      if (a < (minFloat32 / b)) { return v, ErrorOverflow }
   168      
   169      return a * b, nil
   170  }
   171  
   172  func float32BinaryCheckedDiv(a float32, b float32) (v float32, err error) {
   173      if math.IsNaN(float64(a)) { return v, ErrorNaN }
   174      if (b == 0) { return v, ErrorUndefined }
   175      
   176      return a / b, nil
   177  }
   178  
   179  
   180  
   181  func float32NaryAdd(xs ... float32) (result float32) {
   182      for i := 0; i < len(xs); i++ {
   183          result += xs[i]
   184      }
   185      return result
   186  }
   187  
   188  func float32NaryCheckedAdd(xs ... float32) (result float32, err error) {
   189      for i := 0; i < len(xs); i++ {
   190          result, err = float32BinaryCheckedAdd(result, xs[i])
   191          if err != nil { return result, err }
   192      }
   193      return result, nil
   194  }
   195  
   196  func float32NaryMul(xs ... float32) (result float32) {
   197      result = 1
   198      for i := 0; i < len(xs); i++ {
   199          result *= xs[i]
   200      }
   201      return result
   202  }
   203  
   204  func float32NaryCheckedMul(xs ... float32) (result float32, err error) {
   205      result = 1
   206      for i := 0; i < len(xs); i++ {
   207          result, err = float32BinaryCheckedMul(result, xs[i])
   208          if err != nil { return result, err }
   209      }
   210      return result, nil
   211  }
   212  
   213  func float32Reduce(operatorIdentity float32, operator func(float32, float32) float32, elements ... float32) (result float32) {
   214      result = operatorIdentity
   215      for i := 0; i < len(elements); i++ {
   216          result = operator(result, elements[i])
   217      }
   218      return result
   219  }
   220  
   221  func float32CheckedReduce(operatorIdentity float32, operator func(float32, float32) (float32, error), elements ... float32) (result float32, err error) {
   222      result = operatorIdentity
   223      for i := 0; i < len(elements); i++ {
   224          result, err = operator(result, elements[i])
   225          if err != nil { return result, err }
   226      }
   227      return result, err
   228  }
   229  
   230  

View as plain text