github.com/andeya/ameda@v1.5.3/float64.go (about) 1 package ameda 2 3 import ( 4 "fmt" 5 "math" 6 ) 7 8 // Float64ToInterface converts float64 to interface. 9 func Float64ToInterface(v float64) interface{} { 10 return v 11 } 12 13 // Float64ToInterfacePtr converts float64 to *interface. 14 func Float64ToInterfacePtr(v float64) *interface{} { 15 r := Float64ToInterface(v) 16 return &r 17 } 18 19 // Float64ToString converts float64 to string. 20 func Float64ToString(v float64) string { 21 return fmt.Sprintf("%f", v) 22 } 23 24 // Float64ToStringPtr converts float64 to *string. 25 func Float64ToStringPtr(v float64) *string { 26 r := Float64ToString(v) 27 return &r 28 } 29 30 // Float64ToBool converts float64 to bool. 31 func Float64ToBool(v float64) bool { 32 return v != 0 33 } 34 35 // Float64ToBoolPtr converts float64 to *bool. 36 func Float64ToBoolPtr(v float64) *bool { 37 r := Float64ToBool(v) 38 return &r 39 } 40 41 // Float64ToFloat32 converts float64 to float32. 42 func Float64ToFloat32(v float64) (float32, error) { 43 if v > math.MaxFloat32 || v < -math.MaxFloat32 { 44 return 0, errOverflowValue 45 } 46 return float32(v), nil 47 } 48 49 // Float64ToFloat32Ptr converts float64 to *float32. 50 func Float64ToFloat32Ptr(v float64) (*float32, error) { 51 r, err := Float64ToFloat32(v) 52 return &r, err 53 } 54 55 // Float64ToFloat64Ptr converts float64 to *float64. 56 func Float64ToFloat64Ptr(v float64) *float64 { 57 return &v 58 } 59 60 // Float64ToInt converts float64 to int. 61 func Float64ToInt(v float64) (int, error) { 62 if Host64bit { 63 if v > math.MaxInt64 || v < math.MinInt64 { 64 return 0, errOverflowValue 65 } 66 } else { 67 if v > math.MaxInt32 || v < math.MinInt32 { 68 return 0, errOverflowValue 69 } 70 } 71 return int(v), nil 72 73 } 74 75 // Float64ToInt8 converts float64 to int8. 76 func Float64ToInt8(v float64) (int8, error) { 77 if v > math.MaxInt8 || v < math.MinInt8 { 78 return 0, errOverflowValue 79 } 80 return int8(v), nil 81 } 82 83 // Float64ToInt8Ptr converts float64 to *int8. 84 func Float64ToInt8Ptr(v float64) (*int8, error) { 85 r, err := Float64ToInt8(v) 86 return &r, err 87 } 88 89 // Float64ToInt16 converts float64 to int16. 90 func Float64ToInt16(v float64) (int16, error) { 91 if v > math.MaxInt16 || v < math.MinInt16 { 92 return 0, errOverflowValue 93 } 94 return int16(v), nil 95 } 96 97 // Float64ToInt16Ptr converts float64 to *int16. 98 func Float64ToInt16Ptr(v float64) (*int16, error) { 99 r, err := Float64ToInt16(v) 100 return &r, err 101 } 102 103 // Float64ToInt32 converts float64 to int32. 104 func Float64ToInt32(v float64) (int32, error) { 105 if v > math.MaxInt32 || v < math.MinInt32 { 106 return 0, errOverflowValue 107 } 108 return int32(v), nil 109 } 110 111 // Float64ToInt32Ptr converts float64 to *int32. 112 func Float64ToInt32Ptr(v float64) (*int32, error) { 113 r, err := Float64ToInt32(v) 114 return &r, err 115 } 116 117 // Float64ToInt64 converts float64 to int64. 118 func Float64ToInt64(v float64) (int64, error) { 119 if v > math.MaxInt64 || v < math.MinInt64 { 120 return 0, errOverflowValue 121 } 122 return int64(v), nil 123 } 124 125 // Float64ToInt64Ptr converts float64 to *int64. 126 func Float64ToInt64Ptr(v float64) (*int64, error) { 127 r, err := Float64ToInt64(v) 128 return &r, err 129 } 130 131 // Float64ToUint converts float64 to uint. 132 func Float64ToUint(v float64) (uint, error) { 133 if v < 0 { 134 return 0, errNegativeValue 135 } 136 if Host64bit { 137 if v > math.MaxUint64 { 138 return 0, errOverflowValue 139 } 140 } else { 141 if v > math.MaxUint32 { 142 return 0, errOverflowValue 143 } 144 } 145 return uint(v), nil 146 } 147 148 // Float64ToUintPtr converts float64 to *uint. 149 func Float64ToUintPtr(v float64) (*uint, error) { 150 r, err := Float64ToUint(v) 151 return &r, err 152 } 153 154 // Float64ToUint8 converts float64 to uint8. 155 func Float64ToUint8(v float64) (uint8, error) { 156 if v < 0 { 157 return 0, errNegativeValue 158 } 159 if v > math.MaxUint8 { 160 return 0, errOverflowValue 161 } 162 return uint8(v), nil 163 } 164 165 // Float64ToUint8Ptr converts float64 to *uint8. 166 func Float64ToUint8Ptr(v float64) (*uint8, error) { 167 r, err := Float64ToUint8(v) 168 return &r, err 169 } 170 171 // Float64ToUint16 converts float64 to uint16. 172 func Float64ToUint16(v float64) (uint16, error) { 173 if v < 0 { 174 return 0, errNegativeValue 175 } 176 if v > math.MaxUint16 { 177 return 0, errOverflowValue 178 } 179 return uint16(v), nil 180 } 181 182 // Float64ToUint16Ptr converts float64 to *uint16. 183 func Float64ToUint16Ptr(v float64) (*uint16, error) { 184 r, err := Float64ToUint16(v) 185 return &r, err 186 } 187 188 // Float64ToUint32 converts float64 to uint32. 189 func Float64ToUint32(v float64) (uint32, error) { 190 if v < 0 { 191 return 0, errNegativeValue 192 } 193 if v > math.MaxUint32 { 194 return 0, errOverflowValue 195 } 196 return uint32(v), nil 197 } 198 199 // Float64ToUint32Ptr converts float64 to *uint32. 200 func Float64ToUint32Ptr(v float64) (*uint32, error) { 201 r, err := Float64ToUint32(v) 202 return &r, err 203 } 204 205 // Float64ToUint64 converts float64 to uint64. 206 func Float64ToUint64(v float64) (uint64, error) { 207 if v < 0 { 208 return 0, errNegativeValue 209 } 210 if v > math.MaxUint64 { 211 return 0, errOverflowValue 212 } 213 return uint64(v), nil 214 } 215 216 // Float64ToUint64Ptr converts float64 to *uint64. 217 func Float64ToUint64Ptr(v float64) (*uint64, error) { 218 r, err := Float64ToUint64(v) 219 return &r, err 220 }