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  }