convert.go

     1  // run
     2  
     3  // Copyright 2010 The Go Authors. All rights reserved.
     4  // Use of this source code is governed by a BSD-style
     5  // license that can be found in the LICENSE file.
     6  
     7  // Test, near-exhaustive, of converting numbers between types.
     8  // No complex numbers though.
     9  
    10  package main
    11  
    12  var i8 int8;
    13  var u8 uint8;
    14  var i16 int16;
    15  var u16 uint16;
    16  var i32 int32;
    17  var u32 uint32;
    18  var i64 int64;
    19  var u64 uint64;
    20  var f32 float32;
    21  var f64 float64;
    22  
    23  type	big	float64
    24  
    25  type	t	struct {
    26  	from, to	int
    27  	val		big
    28  }
    29  
    30  const (
    31  	ti8	= iota+1
    32  	tu8
    33  	ti16
    34  	tu16
    35  	ti32
    36  	tu32
    37  	ti64
    38  	tu64
    39  	tf32
    40  	tf64
    41  )
    42  
    43  var	x = []t{
    44  
    45  	/* value good in all types (10) */
    46  	{ ti8,  ti8,  10 }, { ti8,  tu8,  10 }, { ti8,  ti16, 10 }, { ti8,  tu16, 10 },
    47  	{ ti8,  ti32, 10 }, { ti8,  tu32, 10 }, { ti8,  ti64, 10 }, { ti8,  tu64, 10 },
    48  	{ ti8,  tf32, 10 }, { ti8,  tf64, 10 },
    49  
    50  	{ tu8,  ti8,  10 }, { tu8,  tu8,  10 }, { tu8,  ti16, 10 }, { tu8,  tu16, 10 },
    51  	{ tu8,  ti32, 10 }, { tu8,  tu32, 10 }, { tu8,  ti64, 10 }, { tu8,  tu64, 10 },
    52  	{ tu8,  tf32, 10 }, { tu8,  tf64, 10 },
    53  
    54  	{ ti16, ti8,  10 }, { ti16, tu8,  10 }, { ti16, ti16, 10 }, { ti16, tu16, 10 },
    55  	{ ti16, ti32, 10 }, { ti16, tu32, 10 }, { ti16, ti64, 10 }, { ti16, tu64, 10 },
    56  	{ ti16, tf32, 10 }, { ti16, tf64, 10 },
    57  
    58  	{ tu16, ti8,  10 }, { tu16, tu8,  10 }, { tu16, ti16, 10 }, { tu16, tu16, 10 },
    59  	{ tu16, ti32, 10 }, { tu16, tu32, 10 }, { tu16, ti64, 10 }, { tu16, tu64, 10 },
    60  	{ tu16, tf32, 10 }, { tu16, tf64, 10 },
    61  
    62  	{ ti32, ti8,  10 }, { ti32, tu8,  10 }, { ti32, ti16, 10 }, { ti32, tu16, 10 },
    63  	{ ti32, ti32, 10 }, { ti32, tu32, 10 }, { ti32, ti64, 10 }, { ti32, tu64, 10 },
    64  	{ ti32, tf32, 10 }, { ti32, tf64, 10 },
    65  
    66  	{ tu32, ti8,  10 }, { tu32, tu8,  10 }, { tu32, ti16, 10 }, { tu32, tu16, 10 },
    67  	{ tu32, ti32, 10 }, { tu32, tu32, 10 }, { tu32, ti64, 10 }, { tu32, tu64, 10 },
    68  	{ tu32, tf32, 10 }, { tu32, tf64, 10 },
    69  
    70  	{ ti64, ti8,  10 }, { ti64, tu8,  10 }, { ti64, ti16, 10 }, { ti64, tu16, 10 },
    71  	{ ti64, ti32, 10 }, { ti64, tu32, 10 }, { ti64, ti64, 10 }, { ti64, tu64, 10 },
    72  	{ ti64, tf32, 10 }, { ti64, tf64, 10 },
    73  
    74  	{ tu64, ti8,  10 }, { tu64, tu8,  10 }, { tu64, ti16, 10 }, { tu64, tu16, 10 },
    75  	{ tu64, ti32, 10 }, { tu64, tu32, 10 }, { tu64, ti64, 10 }, { tu64, tu64, 10 },
    76  	{ tu64, tf32, 10 }, { tu64, tf64, 10 },
    77  
    78  	{ tf32, ti8,  10 }, { tf32, tu8,  10 }, { tf32, ti16, 10 }, { tf32, tu16, 10 },
    79  	{ tf32, ti32, 10 }, { tf32, tu32, 10 }, { tf32, ti64, 10 }, { tf32, tu64, 10 },
    80  	{ tf32, tf32, 10 }, { tf32, tf64, 10 },
    81  
    82  	{ tf64, ti8,  10 }, { tf64, tu8,  10 }, { tf64, ti16, 10 }, { tf64, tu16, 10 },
    83  	{ tf64, ti32, 10 }, { tf64, tu32, 10 }, { tf64, ti64, 10 }, { tf64, tu64, 10 },
    84  	{ tf64, tf32, 10 }, { tf64, tf64, 10 },
    85  
    86  	/* value good in all signed types (-4) */
    87  	{ ti8,  ti8,  -4 }, { ti8,  ti16, -4 },
    88  	{ ti8,  ti32, -4 }, { ti8,  ti64, -4 },
    89  	{ ti8,  tf32, -4 }, { ti8,  tf64, -4 },
    90  
    91  	{ ti16, ti8,  -4 }, { ti16, ti16, -4 },
    92  	{ ti16, ti32, -4 }, { ti16, ti64, -4 },
    93  	{ ti16, tf32, -4 },
    94  
    95  	{ ti32, ti8,  -4 }, { ti32, ti16, -4 },
    96  	{ ti32, ti32, -4 }, { ti32, ti64, -4 },
    97  	{ ti32, tf32, -4 }, { ti32, tf64, -4 },
    98  
    99  	{ ti64, ti8,  -4 }, { ti64, ti16, -4 },
   100  	{ ti64, ti32, -4 }, { ti64, ti64, -4 },
   101  	{ ti64, tf32, -4 },
   102  
   103  	{ tf32, ti8,  -4 }, { tf32, ti16, -4 },
   104  	{ tf32, ti32, -4 }, { tf32, ti64, -4 },
   105  	{ tf32, tf32, -4 },
   106  
   107  	{ tf64, ti8,  -4 }, { tf64, ti16, -4 },
   108  	{ tf64, ti32, -4 }, { tf64, ti64, -4 },
   109  	{ tf64, tf32, -4 }, { tf64, tf64, -4 },
   110  
   111  	/* value good in u8 and up (175) */
   112  	{ tu8,  tu8,  175 }, { tu8,  ti16, 175 }, { tu8,  tu16, 175 },
   113  	{ tu8,  ti32, 175 }, { tu8,  tu32, 175 }, { tu8,  ti64, 175 }, { tu8,  tu64, 175 },
   114  	{ tu8,  tf32, 175 }, { tu8,  tf64, 175 },
   115  
   116  	{ ti16, tu8,  175 }, { ti16, ti16, 175 }, { ti16, tu16, 175 },
   117  	{ ti16, ti32, 175 }, { ti16, tu32, 175 }, { ti16, ti64, 175 }, { ti16, tu64, 175 },
   118  	{ ti16, tf32, 175 }, { ti16, tf64, 175 },
   119  
   120  	{ tu16, tu8,  175 }, { tu16, ti16, 175 }, { tu16, tu16, 175 },
   121  	{ tu16, ti32, 175 }, { tu16, tu32, 175 }, { tu16, ti64, 175 }, { tu16, tu64, 175 },
   122  	{ tu16, tf32, 175 }, { tu16, tf64, 175 },
   123  
   124  	{ ti32, tu8,  175 }, { ti32, ti16, 175 }, { ti32, tu16, 175 },
   125  	{ ti32, ti32, 175 }, { ti32, tu32, 175 }, { ti32, ti64, 175 }, { ti32, tu64, 175 },
   126  	{ ti32, tf32, 175 }, { ti32, tf64, 175 },
   127  
   128  	{ tu32, tu8,  175 }, { tu32, ti16, 175 }, { tu32, tu16, 175 },
   129  	{ tu32, ti32, 175 }, { tu32, tu32, 175 }, { tu32, ti64, 175 }, { tu32, tu64, 175 },
   130  	{ tu32, tf32, 175 }, { tu32, tf64, 175 },
   131  
   132  	{ ti64, tu8,  175 }, { ti64, ti16, 175 }, { ti64, tu16, 175 },
   133  	{ ti64, ti32, 175 }, { ti64, tu32, 175 }, { ti64, ti64, 175 }, { ti64, tu64, 175 },
   134  	{ ti64, tf32, 175 }, { ti64, tf64, 175 },
   135  
   136  	{ tu64, tu8,  175 }, { tu64, ti16, 175 }, { tu64, tu16, 175 },
   137  	{ tu64, ti32, 175 }, { tu64, tu32, 175 }, { tu64, ti64, 175 }, { tu64, tu64, 175 },
   138  	{ tu64, tf32, 175 }, { tu64, tf64, 175 },
   139  
   140  	{ tf32, tu8,  175 }, { tf32, ti16, 175 }, { tf32, tu16, 175 },
   141  	{ tf32, ti32, 175 }, { tf32, tu32, 175 }, { tf32, ti64, 175 }, { tf32, tu64, 175 },
   142  	{ tf32, tf32, 175 }, { tf32, tf64, 175 },
   143  
   144  	{ tf64, tu8,  175 }, { tf64, ti16, 175 }, { tf64, tu16, 175 },
   145  	{ tf64, ti32, 175 }, { tf64, tu32, 175 }, { tf64, ti64, 175 }, { tf64, tu64, 175 },
   146  	{ tf64, tf32, 175 }, { tf64, tf64, 175 },
   147  
   148  	/* value good in u16 and up (41259) */
   149  	{ tu16, tu16, 41259 },
   150  	{ tu16, ti32, 41259 }, { tu16, ti64, 41259 }, { tu16, tu64, 41259 },
   151  	{ tu16, tf32, 41259 }, { tu16, tf64, 41259 },
   152  
   153  	{ ti32, tu16, 41259 },
   154  	{ ti32, ti32, 41259 }, { ti32, tu32, 41259 }, { ti32, ti64, 41259 }, { ti32, tu64, 41259 },
   155  	{ ti32, tf32, 41259 }, { ti32, tf64, 41259 },
   156  
   157  	{ tu32, tu16, 41259 },
   158  	{ tu32, ti32, 41259 }, { tu32, tu32, 41259 }, { tu32, ti64, 41259 }, { tu32, tu64, 41259 },
   159  	{ tu32, tf32, 41259 }, { tu32, tf64, 41259 },
   160  
   161  	{ ti64, tu16, 41259 },
   162  	{ ti64, ti32, 41259 }, { ti64, tu32, 41259 }, { ti64, ti64, 41259 }, { ti64, tu64, 41259 },
   163  	{ ti64, tf32, 41259 }, { ti64, tf64, 41259 },
   164  
   165  	{ tu64, tu16, 41259 },
   166  	{ tu64, ti32, 41259 }, { tu64, tu32, 41259 }, { tu64, ti64, 41259 }, { tu64, tu64, 41259 },
   167  	{ tu64, tf32, 41259 }, { tu64, tf64, 41259 },
   168  
   169  	{ tf32, tu16, 41259 },
   170  	{ tf32, ti32, 41259 }, { tf32, tu32, 41259 }, { tf32, ti64, 41259 }, { tf32, tu64, 41259 },
   171  	{ tf32, tf32, 41259 }, { tf32, tf64, 41259 },
   172  
   173  	{ tf64, tu16, 41259 },
   174  	{ tf64, ti32, 41259 }, { tf64, tu32, 41259 }, { tf64, ti64, 41259 }, { tf64, tu64, 41259 },
   175  	{ tf64, tf32, 41259 }, { tf64, tf64, 41259 },
   176  
   177  	/* value good in u32 and up (3758096384) */
   178  	{ tu32, tu32, 3758096384 }, { tu32, ti64, 3758096384 }, { tu32, tu64, 3758096384 },
   179  	{ tu32, tf32, 3758096384 }, { tu32, tf64, 3758096384 },
   180  
   181  	{ ti64, tu32, 3758096384 }, { ti64, ti64, 3758096384 }, { ti64, tu64, 3758096384 },
   182  	{ ti64, tf32, 3758096384 }, { ti64, tf64, 3758096384 },
   183  
   184  	{ tu64, tu32, 3758096384 }, { tu64, ti64, 3758096384 }, { tu64, tu64, 3758096384 },
   185  	{ tu64, tf32, 3758096384 }, { tu64, tf64, 3758096384 },
   186  
   187  	{ tf32, tu32, 3758096384 }, { tf32, ti64, 3758096384 }, { tf32, tu64, 3758096384 },
   188  	{ tf32, tf32, 3758096384 }, { tf32, tf64, 3758096384 },
   189  
   190  	{ tf64, tu32, 3758096384 }, { tf64, ti64, 3758096384 }, { tf64, tu64, 3758096384 },
   191  	{ tf64, tf32, 3758096384 }, { tf64, tf64, 3758096384 },
   192  
   193  	/* value good in u64 and up (16717361816799281152) */
   194  	{ tu64, tu64, 16717361816799281152 },
   195  	{ tu64, tf32, 16717361816799281152 }, { tu64, tf64, 16717361816799281152 },
   196  
   197  	{ tf32, tu64, 16717361816799281152 },
   198  	{ tf32, tf32, 16717361816799281152 }, { tf32, tf64, 16717361816799281152 },
   199  
   200  	{ tf64, tu64, 16717361816799281152 },
   201  	{ tf64, tf32, 16717361816799281152 }, { tf64, tf64, 16717361816799281152 },
   202  }
   203  
   204  func main() {
   205  	for i:=0; i<len(x); i++ {
   206  		v := x[i].val		// input value
   207  		w := big(0)		// output value
   208  		f := x[i].from		// input type
   209  		t := x[i].to		// output type
   210  
   211  		i8  = 0; u8  = 0; i16 = 0; u16 = 0
   212  		i32 = 0; u32 = 0; i64 = 0; u64 = 0
   213  		f32 = 0; f64 = 0
   214  
   215  		switch f*100 + t {
   216  		default:
   217  			println("missing case", i, v, f, t)
   218  			w = v
   219  
   220  		case ti8*100 + ti8:
   221  			i8 = int8(v); i8 = int8(i8); w = big(i8)
   222  		case ti8*100 + tu8:
   223  			i8 = int8(v); u8 = uint8(i8); w = big(u8)
   224  		case ti8*100 + ti16:
   225  			i8 = int8(v); i16 = int16(i8); w = big(i16)
   226  		case ti8*100 + tu16:
   227  			i8 = int8(v); u16 = uint16(i8); w = big(u16)
   228  		case ti8*100 + ti32:
   229  			i8 = int8(v); i32 = int32(i8); w = big(i32)
   230  		case ti8*100 + tu32:
   231  			i8 = int8(v); u32 = uint32(i8); w = big(u32)
   232  		case ti8*100 + ti64:
   233  			i8 = int8(v); i64 = int64(i8); w = big(i64)
   234  		case ti8*100 + tu64:
   235  			i8 = int8(v); u64 = uint64(i8); w = big(u64)
   236  		case ti8*100 + tf32:
   237  			i8 = int8(v); f32 = float32(i8); w = big(f32)
   238  		case ti8*100 + tf64:
   239  			i8 = int8(v); f64 = float64(i8); w = big(f64)
   240  
   241  		case tu8*100 + ti8:
   242  			u8 = uint8(v); i8 = int8(u8); w = big(i8)
   243  		case tu8*100 + tu8:
   244  			u8 = uint8(v); u8 = uint8(u8); w = big(u8)
   245  		case tu8*100 + ti16:
   246  			u8 = uint8(v); i16 = int16(u8); w = big(i16)
   247  		case tu8*100 + tu16:
   248  			u8 = uint8(v); u16 = uint16(u8); w = big(u16)
   249  		case tu8*100 + ti32:
   250  			u8 = uint8(v); i32 = int32(u8); w = big(i32)
   251  		case tu8*100 + tu32:
   252  			u8 = uint8(v); u32 = uint32(u8); w = big(u32)
   253  		case tu8*100 + ti64:
   254  			u8 = uint8(v); i64 = int64(u8); w = big(i64)
   255  		case tu8*100 + tu64:
   256  			u8 = uint8(v); u64 = uint64(u8); w = big(u64)
   257  		case tu8*100 + tf32:
   258  			u8 = uint8(v); f32 = float32(u8); w = big(f32)
   259  		case tu8*100 + tf64:
   260  			u8 = uint8(v); f64 = float64(u8); w = big(f64)
   261  
   262  		case ti16*100 + ti8:
   263  			i16 = int16(v); i8 = int8(i16); w = big(i8)
   264  		case ti16*100 + tu8:
   265  			i16 = int16(v); u8 = uint8(i16); w = big(u8)
   266  		case ti16*100 + ti16:
   267  			i16 = int16(v); i16 = int16(i16); w = big(i16)
   268  		case ti16*100 + tu16:
   269  			i16 = int16(v); u16 = uint16(i16); w = big(u16)
   270  		case ti16*100 + ti32:
   271  			i16 = int16(v); i32 = int32(i16); w = big(i32)
   272  		case ti16*100 + tu32:
   273  			i16 = int16(v); u32 = uint32(i16); w = big(u32)
   274  		case ti16*100 + ti64:
   275  			i16 = int16(v); i64 = int64(i16); w = big(i64)
   276  		case ti16*100 + tu64:
   277  			i16 = int16(v); u64 = uint64(i16); w = big(u64)
   278  		case ti16*100 + tf32:
   279  			i16 = int16(v); f32 = float32(i16); w = big(f32)
   280  		case ti16*100 + tf64:
   281  			i16 = int16(v); f64 = float64(i16); w = big(f64)
   282  
   283  		case tu16*100 + ti8:
   284  			u16 = uint16(v); i8 = int8(u16); w = big(i8)
   285  		case tu16*100 + tu8:
   286  			u16 = uint16(v); u8 = uint8(u16); w = big(u8)
   287  		case tu16*100 + ti16:
   288  			u16 = uint16(v); i16 = int16(u16); w = big(i16)
   289  		case tu16*100 + tu16:
   290  			u16 = uint16(v); u16 = uint16(u16); w = big(u16)
   291  		case tu16*100 + ti32:
   292  			u16 = uint16(v); i32 = int32(u16); w = big(i32)
   293  		case tu16*100 + tu32:
   294  			u16 = uint16(v); u32 = uint32(u16); w = big(u32)
   295  		case tu16*100 + ti64:
   296  			u16 = uint16(v); i64 = int64(u16); w = big(i64)
   297  		case tu16*100 + tu64:
   298  			u16 = uint16(v); u64 = uint64(u16); w = big(u64)
   299  		case tu16*100 + tf32:
   300  			u16 = uint16(v); f32 = float32(u16); w = big(f32)
   301  		case tu16*100 + tf64:
   302  			u16 = uint16(v); f64 = float64(u16); w = big(f64)
   303  
   304  		case ti32*100 + ti8:
   305  			i32 = int32(v); i8 = int8(i32); w = big(i8)
   306  		case ti32*100 + tu8:
   307  			i32 = int32(v); u8 = uint8(i32); w = big(u8)
   308  		case ti32*100 + ti16:
   309  			i32 = int32(v); i16 = int16(i32); w = big(i16)
   310  		case ti32*100 + tu16:
   311  			i32 = int32(v); u16 = uint16(i32); w = big(u16)
   312  		case ti32*100 + ti32:
   313  			i32 = int32(v); i32 = int32(i32); w = big(i32)
   314  		case ti32*100 + tu32:
   315  			i32 = int32(v); u32 = uint32(i32); w = big(u32)
   316  		case ti32*100 + ti64:
   317  			i32 = int32(v); i64 = int64(i32); w = big(i64)
   318  		case ti32*100 + tu64:
   319  			i32 = int32(v); u64 = uint64(i32); w = big(u64)
   320  		case ti32*100 + tf32:
   321  			i32 = int32(v); f32 = float32(i32); w = big(f32)
   322  		case ti32*100 + tf64:
   323  			i32 = int32(v); f64 = float64(i32); w = big(f64)
   324  
   325  		case tu32*100 + ti8:
   326  			u32 = uint32(v); i8 = int8(u32); w = big(i8)
   327  		case tu32*100 + tu8:
   328  			u32 = uint32(v); u8 = uint8(u32); w = big(u8)
   329  		case tu32*100 + ti16:
   330  			u32 = uint32(v); i16 = int16(u32); w = big(i16)
   331  		case tu32*100 + tu16:
   332  			u32 = uint32(v); u16 = uint16(u32); w = big(u16)
   333  		case tu32*100 + ti32:
   334  			u32 = uint32(v); i32 = int32(u32); w = big(i32)
   335  		case tu32*100 + tu32:
   336  			u32 = uint32(v); u32 = uint32(u32); w = big(u32)
   337  		case tu32*100 + ti64:
   338  			u32 = uint32(v); i64 = int64(u32); w = big(i64)
   339  		case tu32*100 + tu64:
   340  			u32 = uint32(v); u64 = uint64(u32); w = big(u64)
   341  		case tu32*100 + tf32:
   342  			u32 = uint32(v); f32 = float32(u32); w = big(f32)
   343  		case tu32*100 + tf64:
   344  			u32 = uint32(v); f64 = float64(u32); w = big(f64)
   345  
   346  		case ti64*100 + ti8:
   347  			i64 = int64(v); i8 = int8(i64); w = big(i8)
   348  		case ti64*100 + tu8:
   349  			i64 = int64(v); u8 = uint8(i64); w = big(u8)
   350  		case ti64*100 + ti16:
   351  			i64 = int64(v); i16 = int16(i64); w = big(i16)
   352  		case ti64*100 + tu16:
   353  			i64 = int64(v); u16 = uint16(i64); w = big(u16)
   354  		case ti64*100 + ti32:
   355  			i64 = int64(v); i32 = int32(i64); w = big(i32)
   356  		case ti64*100 + tu32:
   357  			i64 = int64(v); u32 = uint32(i64); w = big(u32)
   358  		case ti64*100 + ti64:
   359  			i64 = int64(v); i64 = int64(i64); w = big(i64)
   360  		case ti64*100 + tu64:
   361  			i64 = int64(v); u64 = uint64(i64); w = big(u64)
   362  		case ti64*100 + tf32:
   363  			i64 = int64(v); f32 = float32(i64); w = big(f32)
   364  		case ti64*100 + tf64:
   365  			i64 = int64(v); f64 = float64(i64); w = big(f64)
   366  
   367  		case tu64*100 + ti8:
   368  			u64 = uint64(v); i8 = int8(u64); w = big(i8)
   369  		case tu64*100 + tu8:
   370  			u64 = uint64(v); u8 = uint8(u64); w = big(u8)
   371  		case tu64*100 + ti16:
   372  			u64 = uint64(v); i16 = int16(u64); w = big(i16)
   373  		case tu64*100 + tu16:
   374  			u64 = uint64(v); u16 = uint16(u64); w = big(u16)
   375  		case tu64*100 + ti32:
   376  			u64 = uint64(v); i32 = int32(u64); w = big(i32)
   377  		case tu64*100 + tu32:
   378  			u64 = uint64(v); u32 = uint32(u64); w = big(u32)
   379  		case tu64*100 + ti64:
   380  			u64 = uint64(v); i64 = int64(u64); w = big(i64)
   381  		case tu64*100 + tu64:
   382  			u64 = uint64(v); u64 = uint64(u64); w = big(u64)
   383  		case tu64*100 + tf32:
   384  			u64 = uint64(v); f32 = float32(u64); w = big(f32)
   385  		case tu64*100 + tf64:
   386  			u64 = uint64(v); f64 = float64(u64); w = big(f64)
   387  
   388  		case tf32*100 + ti8:
   389  			f32 = float32(v); i8 = int8(f32); w = big(i8)
   390  		case tf32*100 + tu8:
   391  			f32 = float32(v); u8 = uint8(f32); w = big(u8)
   392  		case tf32*100 + ti16:
   393  			f32 = float32(v); i16 = int16(f32); w = big(i16)
   394  		case tf32*100 + tu16:
   395  			f32 = float32(v); u16 = uint16(f32); w = big(u16)
   396  		case tf32*100 + ti32:
   397  			f32 = float32(v); i32 = int32(f32); w = big(i32)
   398  		case tf32*100 + tu32:
   399  			f32 = float32(v); u32 = uint32(f32); w = big(u32)
   400  		case tf32*100 + ti64:
   401  			f32 = float32(v); i64 = int64(f32); w = big(i64)
   402  		case tf32*100 + tu64:
   403  			f32 = float32(v); u64 = uint64(f32); w = big(u64)
   404  		case tf32*100 + tf32:
   405  			f32 = float32(v); f32 = float32(f32); w = big(f32)
   406  		case tf32*100 + tf64:
   407  			f32 = float32(v); f64 = float64(f32); w = big(f64)
   408  
   409  		case tf64*100 + ti8:
   410  			f64 = float64(v); i8 = int8(f64); w = big(i8)
   411  		case tf64*100 + tu8:
   412  			f64 = float64(v); u8 = uint8(f64); w = big(u8)
   413  		case tf64*100 + ti16:
   414  			f64 = float64(v); i16 = int16(f64); w = big(i16)
   415  		case tf64*100 + tu16:
   416  			f64 = float64(v); u16 = uint16(f64); w = big(u16)
   417  		case tf64*100 + ti32:
   418  			f64 = float64(v); i32 = int32(f64); w = big(i32)
   419  		case tf64*100 + tu32:
   420  			f64 = float64(v); u32 = uint32(f64); w = big(u32)
   421  		case tf64*100 + ti64:
   422  			f64 = float64(v); i64 = int64(f64); w = big(i64)
   423  		case tf64*100 + tu64:
   424  			f64 = float64(v); u64 = uint64(f64); w = big(u64)
   425  		case tf64*100 + tf32:
   426  			f64 = float64(v); f32 = float32(f64); w = big(f32)
   427  		case tf64*100 + tf64:
   428  			f64 = float64(v); f64 = float64(f64); w = big(f64)
   429  		}
   430  		if v != w { println(i, v, w, f, t) }
   431  	}
   432  }
   433
View as plain text