Mirror of forum.nim-lang.org

779 :: float + integer

• AxBen (orginal) [2015-01-22T18:56:13+01:00] view original

  Given the following code:

  import typetraits
  
  var i = 1
  var f = 1.01
  
  echo i.type.name    # int
  echo f.type.name    # float
  echo 1.type.name    # int
  echo 1.01.type.name # float
  
  echo 1 + 1.01   # ok
  echo i + f      # compile-time error
  # Same for:
  # var f2: float = i + f
  Run

  Why shouldn't it be possible to compile this? Is there any rationale/description of this behavior in the manuals?

---

• def (orginal) [2015-01-22T19:14:18+01:00] view original

  You should manually convert number types so that you're aware of what is happening. Do you want an int or a float as result?

  echo i.float + f
  echo i + f.int
  Run

  for 1 + 1.01 it only works because 1 is then assumed to be a float literal.

---

• LeuGim (orginal) [2015-01-22T19:22:43+01:00] view original

  Or you can define a converter to not make manual conversions:

  converter floatToInt(f: float): int = f.int
  echo i + f
  Run

---

• AxBen (orginal) [2015-01-23T08:33:13+01:00] view original

  It's clear that I could do that manually, but:

  1. What about an expression like "var ft1 = 3600 * h1 + 60 * m1 + s1 + ms1 / 1000 + delta", it's quite tedious to inspect it and place my conversions in the right places.

  b) @def: In C/C++/C#/D we got rules for this: use the "more advanced" data type (which would be float in this case). I don't see how such a default would break (which you didn't imply though) anything (the more as 1 + 1.01 works that way). Also - in the case of "var f2: float ..." the result type was specified, and there shouldn't be any ambiguity.

  3. @LeuGim: This - IMHO - is a too basic thing as to write a converter for it.

---

• Araq (orginal) [2015-01-23T09:30:12+01:00] view original

  Int is 64 bits on a 64 bit machine so conversion from int to 64 bit float can lose precision. float is not more "advanced" than int in general so the conversion is not safe.

  Int literals have a special type that is convertible to float implicitly because the actual value is known at compile time and so we can ensure the conversion is safe.

---

• andrea (orginal) [2015-01-23T09:43:24+01:00] view original

  Moreover, it is quite nice to be able to tell when a conversion is taking place. It is not expensive, but it is not free either. OCaml takes a similar approach in that conversions between numeric types have to be explicit

---

• zio_tom78 (orginal) [2015-01-23T12:46:22+01:00] view original

  I write numerical code daily, and I cannot underappreciate the way Nim handles this. Forcing the conversion to be explicit is a huge gain in readability!

  I cannot enumerate all the bugs we have had in our C/C++ codes because of automatic conversions between integers and floating-point numbers. In the C++ code I'm working right now there are many pearls like the following one:

  int detectorIdsSize;
  int odNumber;
  int sizeMPI;
  
  // ...
  int step = static_cast<int>(floor(static_cast<double>(detectorIdsSize * odNumber / sizeMPI))) + 1;
  Run

  (this is just the first result I got using grep "static_cast.*double.*" *.cpp in the source directory!). Obviously, whoever wrote this code was very frightened by C++ automatic conversion rules!

---