vendor/github.com/hashicorp/terraform/lang/funcs/number.go

   1 package funcs
   2
   3 import (
   4         "math"
   5
   6         "github.com/zclconf/go-cty/cty"
   7         "github.com/zclconf/go-cty/cty/function"
   8         "github.com/zclconf/go-cty/cty/gocty"
   9 )
  10
  11 // CeilFunc contructs a function that returns the closest whole number greater
  12 // than or equal to the given value.
  13 var CeilFunc = function.New(&function.Spec{
  14         Params: []function.Parameter{
  15                 {
  16                         Name: "num",
  17                         Type: cty.Number,
  18                 },
  19         },
  20         Type: function.StaticReturnType(cty.Number),
  21         Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
  22                 var val float64
  23                 if err := gocty.FromCtyValue(args[0], &val); err != nil {
  24                         return cty.UnknownVal(cty.String), err
  25                 }
  26                 return cty.NumberIntVal(int64(math.Ceil(val))), nil
  27         },
  28 })
  29
  30 // FloorFunc contructs a function that returns the closest whole number lesser
  31 // than or equal to the given value.
  32 var FloorFunc = function.New(&function.Spec{
  33         Params: []function.Parameter{
  34                 {
  35                         Name: "num",
  36                         Type: cty.Number,
  37                 },
  38         },
  39         Type: function.StaticReturnType(cty.Number),
  40         Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
  41                 var val float64
  42                 if err := gocty.FromCtyValue(args[0], &val); err != nil {
  43                         return cty.UnknownVal(cty.String), err
  44                 }
  45                 return cty.NumberIntVal(int64(math.Floor(val))), nil
  46         },
  47 })
  48
  49 // LogFunc contructs a function that returns the logarithm of a given number in a given base.
  50 var LogFunc = function.New(&function.Spec{
  51         Params: []function.Parameter{
  52                 {
  53                         Name: "num",
  54                         Type: cty.Number,
  55                 },
  56                 {
  57                         Name: "base",
  58                         Type: cty.Number,
  59                 },
  60         },
  61         Type: function.StaticReturnType(cty.Number),
  62         Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
  63                 var num float64
  64                 if err := gocty.FromCtyValue(args[0], &num); err != nil {
  65                         return cty.UnknownVal(cty.String), err
  66                 }
  67
  68                 var base float64
  69                 if err := gocty.FromCtyValue(args[1], &base); err != nil {
  70                         return cty.UnknownVal(cty.String), err
  71                 }
  72
  73                 return cty.NumberFloatVal(math.Log(num) / math.Log(base)), nil
  74         },
  75 })
  76
  77 // PowFunc contructs a function that returns the logarithm of a given number in a given base.
  78 var PowFunc = function.New(&function.Spec{
  79         Params: []function.Parameter{
  80                 {
  81                         Name: "num",
  82                         Type: cty.Number,
  83                 },
  84                 {
  85                         Name: "power",
  86                         Type: cty.Number,
  87                 },
  88         },
  89         Type: function.StaticReturnType(cty.Number),
  90         Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
  91                 var num float64
  92                 if err := gocty.FromCtyValue(args[0], &num); err != nil {
  93                         return cty.UnknownVal(cty.String), err
  94                 }
  95
  96                 var power float64
  97                 if err := gocty.FromCtyValue(args[1], &power); err != nil {
  98                         return cty.UnknownVal(cty.String), err
  99                 }
 100
 101                 return cty.NumberFloatVal(math.Pow(num, power)), nil
 102         },
 103 })
 104
 105 // SignumFunc contructs a function that returns the closest whole number greater
 106 // than or equal to the given value.
 107 var SignumFunc = function.New(&function.Spec{
 108         Params: []function.Parameter{
 109                 {
 110                         Name: "num",
 111                         Type: cty.Number,
 112                 },
 113         },
 114         Type: function.StaticReturnType(cty.Number),
 115         Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
 116                 var num int
 117                 if err := gocty.FromCtyValue(args[0], &num); err != nil {
 118                         return cty.UnknownVal(cty.String), err
 119                 }
 120                 switch {
 121                 case num < 0:
 122                         return cty.NumberIntVal(-1), nil
 123                 case num > 0:
 124                         return cty.NumberIntVal(+1), nil
 125                 default:
 126                         return cty.NumberIntVal(0), nil
 127                 }
 128         },
 129 })
 130
 131 // Ceil returns the closest whole number greater than or equal to the given value.
 132 func Ceil(num cty.Value) (cty.Value, error) {
 133         return CeilFunc.Call([]cty.Value{num})
 134 }
 135
 136 // Floor returns the closest whole number lesser than or equal to the given value.
 137 func Floor(num cty.Value) (cty.Value, error) {
 138         return FloorFunc.Call([]cty.Value{num})
 139 }
 140
 141 // Log returns returns the logarithm of a given number in a given base.
 142 func Log(num, base cty.Value) (cty.Value, error) {
 143         return LogFunc.Call([]cty.Value{num, base})
 144 }
 145
 146 // Pow returns the logarithm of a given number in a given base.
 147 func Pow(num, power cty.Value) (cty.Value, error) {
 148         return PowFunc.Call([]cty.Value{num, power})
 149 }
 150
 151 // Signum determines the sign of a number, returning a number between -1 and
 152 // 1 to represent the sign.
 153 func Signum(num cty.Value) (cty.Value, error) {
 154         return SignumFunc.Call([]cty.Value{num})
 155 }