Fuzion Logo
flang.dev — The Fuzion Language Portal
JavaScript seems to be disabled. Functionality is limited.

f64.fz


# This file is part of the Fuzion language implementation.
#
# The Fuzion language implementation is free software: you can redistribute it
# and/or modify it under the terms of the GNU General Public License as published
# by the Free Software Foundation, version 3 of the License.
#
# The Fuzion language implementation is distributed in the hope that it will be
# useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
# License for more details.
#
# You should have received a copy of the GNU General Public License along with The
# Fuzion language implementation.  If not, see <https://www.gnu.org/licenses/>.


# -----------------------------------------------------------------------
#
#  Tokiwa Software GmbH, Germany
#
#  Source code of Fuzion standard library feature f64
#
#  Author: Fridtjof Siebert (siebert@tokiwa.software)
#
# -----------------------------------------------------------------------

# f64 -- 64 bit floating point values
#
#
# f64 are binary64-numbers as defined in the IEEE 754-2019 standard, see
# https://ieeexplore.ieee.org/servlet/opac?punumber=8766227
#
f64(val f64) : float f64, f64s is

  redef thiz        => f64.this.val
  redef orderedThis => f64.this.val


  # basic operations: 'prefix -' (negation)
  redef prefix - f64 is intrinsic
  infix + (other f64) f64 is intrinsic
  infix - (other f64) f64 is intrinsic
  infix * (other f64) f64 is intrinsic
  infix / (other f64) f64 is intrinsic
  infix % (other f64) f64 is intrinsic
  infix ** (other f64) f64 is intrinsic


  # comparison
  redef infix == (other f64) bool is intrinsic
  redef infix != (other f64) bool is intrinsic
  redef infix <  (other f64) bool is intrinsic
  redef infix <= (other f64) bool is intrinsic
  redef infix >  (other f64) bool is intrinsic
  redef infix >= (other f64) bool is intrinsic


  # conversion

  # NaN is converted to 0
  # anything greater than i64.max as well as  ∞ is i64.max
  # anything lower   than i64.min as well as -∞ is i64.min
  as_i64_lax i64 is intrinsic


  fits_in_i64 =>
    f64.this >= i64s.min.as_f64 && f64.this <= i64s.max.as_f64


  redef as_i64
    pre
      safety: fits_in_i64
    => as_i64_lax


  as_f32 f32 is intrinsic


  # casting bit representation to u64
  castTo_u64 u64 is intrinsic


  # create hash code from this number
  hash u64 is
    castTo_u64.hash


  # the fraction of this floating point number
  redef fract f64 is
    if f64s.isNaN val
      NaN
    else if val < 0
      -(-val).fract
    else if val < 1
      val
    else
      bits := castTo_u64
      fract_bits := significandBits.as_u64 - 1
      bias := (u64 2 ** (exponentBits.as_u64 - 1) - 1)
      mask := u64 2 ** exponentBits.as_u64 - 1
      e := ((bits >> fract_bits) & mask) - bias
      if (e < fract_bits)
        x := bits & (u64s.max << (fract_bits - e))
        val - x.castTo_f64
      else
        0.0


  # convert this to a string.
  #
  redef asString string is intrinsic


# f64s -- unit type defining features related to f64 but not requiring an
# instance
#
f64s : floats f64 is

  redef name => "f64"

  redef zero => f64 0
  redef one  => f64 1

  redef bytes => 8
  significandBits => 53
  exponentBits => 11


  redef isNaN(val f64) bool is intrinsic

  redef ℇ => 2.7182818284590452354

  redef π => 3.14159265358979323846


  redef minExp i32 is intrinsic
  redef maxExp i32 is intrinsic
  redef minPositive f64 is intrinsic
  redef max f64 is intrinsic
  redef epsilon f64 is intrinsic

  redef from_i64(val i64) f64 is
    val.as_f64

  redef squareRoot(val f64) f64 is intrinsic

  redef exp(val f64) f64 is intrinsic
  redef log(val f64) f64 is intrinsic

  redef sin(val f64) f64 is intrinsic
  redef cos(val f64) f64 is intrinsic
  redef tan(val f64) f64 is intrinsic
  redef asin(val f64) f64 is intrinsic
  redef acos(val f64) f64 is intrinsic
  redef atan(val f64) f64 is intrinsic
  redef atan2(y f64, x f64) f64 is intrinsic

  redef sinh(val f64) f64 is intrinsic
  redef cosh(val f64) f64 is intrinsic
  redef tanh(val f64) f64 is intrinsic