Iterate/Floating-point: Difference between revisions

From Esolang
Jump to navigation Jump to search
← Older editNewer edit →
Content deleted Content added
Aadenboy (talk | contribs)
851 edits
reimplement
Aadenboy (talk | contribs)
851 edits
No edit summary
Line 7: Line 7:
== Parse string as float ==
== Parse string as float ==
<pre>
<pre>
((*))boiler.it

(*)1<
(*)1<
// globals
*0< (sign*)<> >
*0< (sign*)<> >
*0< (mantissa*)<> >
*0< (mantissa*)<> >
Line 16: Line 17:
*1< (fraction_length*)<> >
*1< (fraction_length*)<> >


// check the first character for the sign, or append it to the integer if it is a number
*~?< (first*)<> >
*~?< (first*)<> >
(plus_(compare*))<=first><43>
(plus_(compare*))<=first><43>
Line 30: Line 30:
>
>


// parse any further number characters and add it to the integer
(parse_integer*)∞<
(parse_integer*)∞<
$parse_char
$parse_char
*~?< (parse_char*)<> >
*~?< (parse_char*)<> >
(period_(compare*))<=parse_char><46> // check for decimal point
(period_(compare*))<=parse_char><46>
(parse_null_(not*))<=parse_char>
(parse_null_(not*))<=parse_char>
(parse_char_(is_number*))<=parse_char><
(parse_char_(is_number*))<=parse_char><
Line 47: Line 46:
>
>


// if there was a decimal point, parse any further number characters and add it to the fraction
*=do_fraction<
*=do_fraction<
(parse_fraction*)∞<
(parse_fraction*)∞<
Line 57: Line 55:
(fraction_(mul*))<=fraction><10>
(fraction_(mul*))<=fraction><10>
$fraction *=fraction_result< (fraction*)<> >
$fraction *=fraction_result< (fraction*)<> >
(fraction_length_(mul*))<=fraction_length><10> // keep track of the length in base-10 for later
(fraction_length_(mul*))<=fraction_length><10>
$fraction_length *=fraction_length_result< (fraction_length*)<> >
$fraction_length *=fraction_length_result< (fraction_length*)<> >
*=parse_char_out_result< (fraction*)<> >
*=parse_char_out_result< (fraction*)<> >
Line 66: Line 64:
>
>


*1< (decrease_bias*)<> > // if there is no integer, the fraction will determine the bias
*1< (decrease_bias*)<> >

// build the mantissa from the integer
(build_mantissa*)∞<
(build_mantissa*)∞<
(integer_(is_0_1_else*))<=integer>< !build_mantissa >< $decrease_bias !build_mantissa ><> // stop once we reach the most significant bit
(integer_(is_0_1_else*))<=integer>< !build_mantissa >< $decrease_bias !build_mantissa ><>
$decrease_bias
$decrease_bias
(shr_(div*))<=integer><2> // shift right one bit
(shr_(div*))<=integer><2>
$integer *=shr_quotient< (integer*)<> > // set current integer to quotient
$integer *=shr_quotient< (integer*)<> >
*1< (mantissa_shifts*)<> > // record each shift
*1< (mantissa_shifts*)<> >
*=shr_remainder< *=mantissa_length< (mantissa*)<> > > // push the remainder to the top of the mantissa
*=shr_remainder< *=mantissa_length< (mantissa*)<> > >
(shr_(mul*))<=mantissa_length><2> // shift left the mantissa length
(shr_(mul*))<=mantissa_length><2>
$mantissa_length *=shr_result< (mantissa_length*)<> >
$mantissa_length *=shr_result< (mantissa_length*)<> >
>
>
*127< (exponent*)<> >
*127< (exponent*)<> >
*=mantissa_shifts< (exponent*)<> > // calculate the biased exponent
*=mantissa_shifts< (exponent*)<> >
(pad_(sub*))<23><=mantissa_shifts> // determine how many zeroes to pad
(pad_(sub*))<23><=mantissa_shifts>
*=pad_result<
*=pad_result<
(pad_shl_(mul*))<=mantissa><2> // pad
(pad_shl_(mul*))<=mantissa><2>
$mantissa *=pad_shl_result< (mantissa*)<> >
$mantissa *=pad_shl_result< (mantissa*)<> >
>
>
(extra_pad_(if_else*))<=decrease_bias>< (pad_result*)<> ><>
*=pad_result< (pad_remaining*)<> > // keep track of how many bits are left for the fraction
*=pad_result< (pad_remaining*)<> >
// build the fraction part of the mantissa (with one extra digit)
(build_mantissa_fraction*)∞<
(build_mantissa_fraction*)∞<
(fraction_1_(is_0*))<=fraction>< !build_mantissa_fraction > // stop once fraction is zero
(fraction_1_(is_0*))<=fraction>< !build_mantissa_fraction >
(fraction_(mul*))<=fraction><2> // multiply the fraction by two
(fraction_(mul*))<=fraction><2>
$fraction *=fraction_result< (fraction*)<> >
$fraction *=fraction_result< (fraction*)<> >
(decrease_bias_1_(if_else*))<=decrease_bias>< // decrease the bias for every zero first encountered (if allowed)
(decrease_bias_1_(if_else*))<=decrease_bias><
(exponent_(sub*))<=exponent><1>
(exponent_(sub*))<=exponent><1>
$exponent *=exponent_result< (exponent*)<> >
$exponent *=exponent_result< (exponent*)<> >
><>
><>
(fraction_length_(compare*))<=fraction><=fraction_length> // once the fraction exceeds the length in base-10 determined earlier...
(fraction_length_(compare*))<=fraction><=fraction_length>
(fraction_length_(or*))<=fraction_length_equal><=fraction_length_greater>
(fraction_length_(or*))<=fraction_length_equal><=fraction_length_greater>
(fraction_length_(if_else*))<=fraction_length_result><
(fraction_length_(if_else*))<=fraction_length_result><
(fraction_(sub*))<=fraction><=fraction_length> // set it to the remainder
(fraction_(sub*))<=fraction><=fraction_length>
$fraction *=fraction_result< (fraction*)<> >
$fraction *=fraction_result< (fraction*)<> >
*1< (fraction_mantissa*)<> > // and push a bit to the mantissa
*1< (fraction_mantissa*)<> >
(decrease_bias_2_(if_else*))<=decrease_bias>< // reset counters if we were decreasing the bias (and therefore normalizing the number)
(decrease_bias_2_(if_else*))<=decrease_bias><
$decrease_bias
$decrease_bias
$fraction_mantissa
$fraction_mantissa
Line 108: Line 104:
$pad_remaining *=pad_result< (pad_remaining*)<> >
$pad_remaining *=pad_result< (pad_remaining*)<> >
>< (fraction_mantissa_length*)<>>
>< (fraction_mantissa_length*)<>>
(fraction_2_(is_0*))<=fraction>< !build_mantissa_fraction > // if zero, stop
(fraction_2_(is_0*))<=fraction>< !build_mantissa_fraction >
>< (fraction_mantissa_length*)<> >
>< (fraction_mantissa_length*)<> >
(pad_remaining_(is_0*))<=pad_remaining>< !build_mantissa_fraction > // if no more bits left for the mantissa, stop
(pad_remaining_(is_0*))<=pad_remaining>< !build_mantissa_fraction >
(decrease_bias_3_(is_0*))<=decrease_bias>< // if we're not decreasing the bias, start counting down
(decrease_bias_3_(is_0*))<=decrease_bias><
(pad_remaining_(sub*))<=pad_remaining><1>
(pad_remaining_(sub*))<=pad_remaining><1>
$pad_remaining *=pad_remaining_result< (pad_remaining*)<> >
$pad_remaining *=pad_remaining_result< (pad_remaining*)<> >
>
>
(fraction_mantissa_(mul*))<=fraction_mantissa><2> // shift mantissa left
(fraction_mantissa_(mul*))<=fraction_mantissa><2>
$fraction_mantissa *=fraction_mantissa_result< (fraction_mantissa*)<> >
$fraction_mantissa *=fraction_mantissa_result< (fraction_mantissa*)<> >
>
>
(round_(div*))<=fraction_mantissa><2> // round the lowest digit by diving in half
(round_(div*))<=fraction_mantissa><2>
$fraction_mantissa *=round_quotient< (fraction_mantissa*)<> >
$fraction_mantissa *=round_quotient< (fraction_mantissa*)<> >
*=round_remainder< (fraction_mantissa*)<> > // add the remainder to round up if possible
*=round_remainder< (fraction_mantissa*)<> >
*=pad_result< (pad_temp*)<> >
*=pad_result< (pad_temp*)<> >
(pad_(sub*))<=pad_temp><=fraction_mantissa_length>
(pad_(sub*))<=pad_temp><=fraction_mantissa_length>
*=pad_result<
*=pad_result<
(fraction_mantissa_(mul*))<=fraction_mantissa><2> // pad the fraction
(fraction_mantissa_(mul*))<=fraction_mantissa><2>
$fraction_mantissa *=fraction_mantissa_result< (fraction_mantissa*)<> >
$fraction_mantissa *=fraction_mantissa_result< (fraction_mantissa*)<> >
>
>
*=fraction_mantissa< (mantissa*)<> >
*=fraction_mantissa< (mantissa*)<> >


// set the exponent to 0 if the whole number was equal to zero
(mantissa_nil_(not*))<=mantissa>
(mantissa_nil_(not*))<=mantissa>
(is_zero_total_(and*))<=decrease_bias><=mantissa_nil_result>
(is_zero_total_(and*))<=decrease_bias><=mantissa_nil_result>
(is_zero_total_(if_else*))<=is_zero_total_result>< $exponent ><>
(is_zero_total_(if_else*))<=is_zero_total_result>< $exponent ><>


// print result
(sign_(print_num*))<=sign>
(sign_(print_num*))<=sign>
(nl_(print_char*))<10>
(nl_(print_char*))<10>

Revision as of 16:33, 18 November 2025

← Back to Iterate

This implements floating point algorithms into Iterate, following IEEE standard. For performance, the sign, exponent, and mantissa will be stored separately.

Programs are uncompiled.

Parse string as float

((*))boiler.it

(*)1<
  *0< (sign*)<> >
  *0< (mantissa*)<> >
  *1< (mantissa_length*)<> >
  *0< (integer*)<> >
  *0< (fraction*)<> >
  *1< (fraction_length*)<> >

  *~?< (first*)<> >
  (plus_(compare*))<=first><43>
  (minus_(compare*))<=first><45>
  (first_(is_number*))<=first><
    *=first_out_result< (integer*)<> >
  ><
    (plus_(if_else*))<=plus_equal><><
      (minus_(if_else*))<=minus_equal><
        *1< (sign*)<> >
      >< !^ >
    >
  >

  (parse_integer*)∞<
    $parse_char
    *~?< (parse_char*)<> >
    (period_(compare*))<=parse_char><46>
    (parse_null_(not*))<=parse_char>
    (parse_char_(is_number*))<=parse_char><
      (integer_(mul*))<=integer><10>
      $integer *=integer_result< (integer*)<> >
      *=parse_char_out_result< (integer*)<> >
    ><
      (period_(if_else*))<=period_equal>< (do_fraction*)<> !parse_integer ><
        (parse_null_(if_else*))<=parse_null_result>< !parse_integer >< !^ >
      >
    >
  >

  *=do_fraction<
    (parse_fraction*)∞<
      $parse_char
  
      *~?< (parse_char*)<> >
      (parse_null_(not*))<=parse_char>
      (parse_char_(is_number*))<=parse_char><
        (fraction_(mul*))<=fraction><10>
        $fraction *=fraction_result< (fraction*)<> >
        (fraction_length_(mul*))<=fraction_length><10>
        $fraction_length *=fraction_length_result< (fraction_length*)<> >
        *=parse_char_out_result< (fraction*)<> >
      ><
        (parse_null_(if_else*))<=parse_null_result>< !parse_fraction >< !^ >
      >
    >
  >

  *1< (decrease_bias*)<> >
  (build_mantissa*)∞<
    (integer_(is_0_1_else*))<=integer>< !build_mantissa >< $decrease_bias !build_mantissa ><>
    $decrease_bias
    (shr_(div*))<=integer><2>
    $integer *=shr_quotient< (integer*)<> >
    *1< (mantissa_shifts*)<> >
    *=shr_remainder< *=mantissa_length< (mantissa*)<> > >
    (shr_(mul*))<=mantissa_length><2>
    $mantissa_length *=shr_result< (mantissa_length*)<> >
  >
  *127< (exponent*)<> >
  *=mantissa_shifts< (exponent*)<> >
  (pad_(sub*))<23><=mantissa_shifts>
  *=pad_result<
    (pad_shl_(mul*))<=mantissa><2>
    $mantissa *=pad_shl_result< (mantissa*)<> >
  >
  (extra_pad_(if_else*))<=decrease_bias>< (pad_result*)<> ><>
  *=pad_result< (pad_remaining*)<> >
  (build_mantissa_fraction*)∞<
    (fraction_1_(is_0*))<=fraction>< !build_mantissa_fraction >
    (fraction_(mul*))<=fraction><2>
    $fraction *=fraction_result< (fraction*)<> >
    (decrease_bias_1_(if_else*))<=decrease_bias><
      (exponent_(sub*))<=exponent><1>
      $exponent *=exponent_result< (exponent*)<> >
    ><>
    (fraction_length_(compare*))<=fraction><=fraction_length>
    (fraction_length_(or*))<=fraction_length_equal><=fraction_length_greater>
    (fraction_length_(if_else*))<=fraction_length_result><
      (fraction_(sub*))<=fraction><=fraction_length>
      $fraction *=fraction_result< (fraction*)<> >
      *1< (fraction_mantissa*)<> >
      (decrease_bias_2_(if_else*))<=decrease_bias><
        $decrease_bias
        $fraction_mantissa
        $fraction_mantissa_length
        $pad_remaining *=pad_result< (pad_remaining*)<> >
      >< (fraction_mantissa_length*)<>>
      (fraction_2_(is_0*))<=fraction>< !build_mantissa_fraction >
    >< (fraction_mantissa_length*)<> >
    (pad_remaining_(is_0*))<=pad_remaining>< !build_mantissa_fraction >
    (decrease_bias_3_(is_0*))<=decrease_bias><
      (pad_remaining_(sub*))<=pad_remaining><1>
      $pad_remaining *=pad_remaining_result< (pad_remaining*)<> >
    >
    (fraction_mantissa_(mul*))<=fraction_mantissa><2>
    $fraction_mantissa *=fraction_mantissa_result< (fraction_mantissa*)<> >
  >
  (round_(div*))<=fraction_mantissa><2>
  $fraction_mantissa *=round_quotient< (fraction_mantissa*)<> >
  *=round_remainder< (fraction_mantissa*)<> >
  *=pad_result< (pad_temp*)<> >
  (pad_(sub*))<=pad_temp><=fraction_mantissa_length>
  *=pad_result<
    (fraction_mantissa_(mul*))<=fraction_mantissa><2>
    $fraction_mantissa *=fraction_mantissa_result< (fraction_mantissa*)<> >
  >
  *=fraction_mantissa< (mantissa*)<> >

  (mantissa_nil_(not*))<=mantissa>
  (is_zero_total_(and*))<=decrease_bias><=mantissa_nil_result>
  (is_zero_total_(if_else*))<=is_zero_total_result>< $exponent ><>

  (sign_(print_num*))<=sign>
  (nl_(print_char*))<10>
  (exponent_(print_num*))<=exponent>
  (nl_(print_char*))<10>
  (mantissa_(print_num*))<=mantissa>
>
Retrieved from "https://esolangs.org/w/index.php?title=Iterate/Floating-point&oldid=168639"