slamch_8c.html

来自「SuperLU is a general purpose library for」· HTML 代码 · 共 711 行 · 第 1/2 页

        </tr>
        <tr>
          <td class="md" nowrap align="right"></td>
          <td class="md"></td>
          <td class="md" nowrap>int *&nbsp;</td>
          <td class="mdname" nowrap> <em>rnd</em>, </td>
        </tr>
        <tr>
          <td class="md" nowrap align="right"></td>
          <td class="md"></td>
          <td class="md" nowrap>float *&nbsp;</td>
          <td class="mdname" nowrap> <em>eps</em>, </td>
        </tr>
        <tr>
          <td class="md" nowrap align="right"></td>
          <td class="md"></td>
          <td class="md" nowrap>int *&nbsp;</td>
          <td class="mdname" nowrap> <em>emin</em>, </td>
        </tr>
        <tr>
          <td class="md" nowrap align="right"></td>
          <td class="md"></td>
          <td class="md" nowrap>float *&nbsp;</td>
          <td class="mdname" nowrap> <em>rmin</em>, </td>
        </tr>
        <tr>
          <td class="md" nowrap align="right"></td>
          <td class="md"></td>
          <td class="md" nowrap>int *&nbsp;</td>
          <td class="mdname" nowrap> <em>emax</em>, </td>
        </tr>
        <tr>
          <td class="md" nowrap align="right"></td>
          <td class="md"></td>
          <td class="md" nowrap>float *&nbsp;</td>
          <td class="mdname" nowrap> <em>rmax</em></td>
        </tr>
        <tr>
          <td class="md"></td>
          <td class="md">)&nbsp;</td>
          <td class="md" colspan="2"></td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table cellspacing="5" cellpadding="0" border="0">
  <tr>
    <td>
      &nbsp;
    </td>
    <td>

<p>
<pre>
    Purpose   
    =======</pre><p>
<pre>    SLAMC2 determines the machine parameters specified in its argument   
    list.</pre><p>
<pre>    Arguments   
    =========</pre><p>
<pre>    BETA    (output) INT   
            The base of the machine.</pre><p>
<pre>    T       (output) INT   
            The number of ( BETA ) digits in the mantissa.</pre><p>
<pre>    RND     (output) INT   
            Specifies whether proper rounding  ( RND = .TRUE. )  or   
            chopping  ( RND = .FALSE. )  occurs in addition. This may not</pre><p>
<pre>            be a reliable guide to the way in which the machine performs</pre><p>
<pre>            its arithmetic.</pre><p>
<pre>    EPS     (output) FLOAT   
            The smallest positive number such that</pre><p>
<pre>               fl( 1.0 - EPS ) .LT. 1.0,</pre><p>
<pre>            where fl denotes the computed value.</pre><p>
<pre>    EMIN    (output) INT   
            The minimum exponent before (gradual) underflow occurs.</pre><p>
<pre>    RMIN    (output) FLOAT   
            The smallest normalized number for the machine, given by   
            BASE**( EMIN - 1 ), where  BASE  is the floating point value</pre><p>
<pre>            of BETA.</pre><p>
<pre>    EMAX    (output) INT   
            The maximum exponent before overflow occurs.</pre><p>
<pre>    RMAX    (output) FLOAT   
            The largest positive number for the machine, given by   
            BASE**EMAX * ( 1 - EPS ), where  BASE  is the floating point</pre><p>
<pre>            value of BETA.</pre><p>
<pre>    Further Details   
    ===============</pre><p>
<pre>    The computation of  EPS  is based on a routine PARANOIA by   
    W. Kahan of the University of California at Berkeley.</pre><p>
<pre>   ===================================================================== 
</pre>     </td>
  </tr>
</table>
<a class="anchor" name="a422da346f4ae26603bbc9b657191e5f"></a><!-- doxytag: member="slamch.c::slamc3_" ref="a422da346f4ae26603bbc9b657191e5f" args="(float *a, float *b)" --><p>
<table class="mdTable" cellpadding="2" cellspacing="0">
  <tr>
    <td class="mdRow">
      <table cellpadding="0" cellspacing="0" border="0">
        <tr>
          <td class="md" nowrap valign="top">double slamc3_           </td>
          <td class="md" valign="top">(&nbsp;</td>
          <td class="md" nowrap valign="top">float *&nbsp;</td>
          <td class="mdname" nowrap> <em>a</em>, </td>
        </tr>
        <tr>
          <td class="md" nowrap align="right"></td>
          <td class="md"></td>
          <td class="md" nowrap>float *&nbsp;</td>
          <td class="mdname" nowrap> <em>b</em></td>
        </tr>
        <tr>
          <td class="md"></td>
          <td class="md">)&nbsp;</td>
          <td class="md" colspan="2"></td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table cellspacing="5" cellpadding="0" border="0">
  <tr>
    <td>
      &nbsp;
    </td>
    <td>

<p>
<pre>
    Purpose   
    =======</pre><p>
<pre>    SLAMC3  is intended to force  A  and  B  to be stored prior to doing</pre><p>
<pre>    the addition of  A  and  B ,  for use in situations where optimizers</pre><p>
<pre>    might hold one of these in a register.</pre><p>
<pre>    Arguments   
    =========</pre><p>
<pre>    A, B    (input) FLOAT   
            The values A and B.</pre><p>
<pre>   ===================================================================== 
</pre>     </td>
  </tr>
</table>
<a class="anchor" name="0f5092460355cf3d3461688e37cc70a0"></a><!-- doxytag: member="slamch.c::slamc4_" ref="0f5092460355cf3d3461688e37cc70a0" args="(int *emin, float *start, int *base)" --><p>
<table class="mdTable" cellpadding="2" cellspacing="0">
  <tr>
    <td class="mdRow">
      <table cellpadding="0" cellspacing="0" border="0">
        <tr>
          <td class="md" nowrap valign="top">int slamc4_           </td>
          <td class="md" valign="top">(&nbsp;</td>
          <td class="md" nowrap valign="top">int *&nbsp;</td>
          <td class="mdname" nowrap> <em>emin</em>, </td>
        </tr>
        <tr>
          <td class="md" nowrap align="right"></td>
          <td class="md"></td>
          <td class="md" nowrap>float *&nbsp;</td>
          <td class="mdname" nowrap> <em>start</em>, </td>
        </tr>
        <tr>
          <td class="md" nowrap align="right"></td>
          <td class="md"></td>
          <td class="md" nowrap>int *&nbsp;</td>
          <td class="mdname" nowrap> <em>base</em></td>
        </tr>
        <tr>
          <td class="md"></td>
          <td class="md">)&nbsp;</td>
          <td class="md" colspan="2"></td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table cellspacing="5" cellpadding="0" border="0">
  <tr>
    <td>
      &nbsp;
    </td>
    <td>

<p>
<pre>
    Purpose   
    =======</pre><p>
<pre>    SLAMC4 is a service routine for SLAMC2.</pre><p>
<pre>    Arguments   
    =========</pre><p>
<pre>    EMIN    (output) EMIN   
            The minimum exponent before (gradual) underflow, computed by</pre><p>
<pre>            setting A = START and dividing by BASE until the previous A   
            can not be recovered.</pre><p>
<pre>    START   (input) FLOAT   
            The starting point for determining EMIN.</pre><p>
<pre>    BASE    (input) INT   
            The base of the machine.</pre><p>
<pre>   ===================================================================== 
</pre>     </td>
  </tr>
</table>
<a class="anchor" name="ed7eefa5a851c36909eee77beed124b0"></a><!-- doxytag: member="slamch.c::slamc5_" ref="ed7eefa5a851c36909eee77beed124b0" args="(int *beta, int *p, int *emin, int *ieee, int *emax, float *rmax)" --><p>
<table class="mdTable" cellpadding="2" cellspacing="0">
  <tr>
    <td class="mdRow">
      <table cellpadding="0" cellspacing="0" border="0">
        <tr>
          <td class="md" nowrap valign="top">int slamc5_           </td>
          <td class="md" valign="top">(&nbsp;</td>
          <td class="md" nowrap valign="top">int *&nbsp;</td>
          <td class="mdname" nowrap> <em>beta</em>, </td>
        </tr>
        <tr>
          <td class="md" nowrap align="right"></td>
          <td class="md"></td>
          <td class="md" nowrap>int *&nbsp;</td>
          <td class="mdname" nowrap> <em>p</em>, </td>
        </tr>
        <tr>
          <td class="md" nowrap align="right"></td>
          <td class="md"></td>
          <td class="md" nowrap>int *&nbsp;</td>
          <td class="mdname" nowrap> <em>emin</em>, </td>
        </tr>
        <tr>
          <td class="md" nowrap align="right"></td>
          <td class="md"></td>
          <td class="md" nowrap>int *&nbsp;</td>
          <td class="mdname" nowrap> <em>ieee</em>, </td>
        </tr>
        <tr>
          <td class="md" nowrap align="right"></td>
          <td class="md"></td>
          <td class="md" nowrap>int *&nbsp;</td>
          <td class="mdname" nowrap> <em>emax</em>, </td>
        </tr>
        <tr>
          <td class="md" nowrap align="right"></td>
          <td class="md"></td>
          <td class="md" nowrap>float *&nbsp;</td>
          <td class="mdname" nowrap> <em>rmax</em></td>
        </tr>
        <tr>
          <td class="md"></td>
          <td class="md">)&nbsp;</td>
          <td class="md" colspan="2"></td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table cellspacing="5" cellpadding="0" border="0">
  <tr>
    <td>
      &nbsp;
    </td>
    <td>

<p>
<pre>
    Purpose   
    =======</pre><p>
<pre>    SLAMC5 attempts to compute RMAX, the largest machine floating-point   
    number, without overflow.  It assumes that EMAX + <a class="el" href="slamch_8c.html#3aa069ac3980707dae1e0530f50d59e4">abs(EMIN)</a> sum   
    approximately to a power of 2.  It will fail on machines where this   
    assumption does not hold, for example, the Cyber 205 (EMIN = -28625,</pre><p>
<pre>    EMAX = 28718).  It will also fail if the value supplied for EMIN is   
    too large (i.e. too close to zero), probably with overflow.</pre><p>
<pre>    Arguments   
    =========</pre><p>
<pre>    BETA    (input) INT   
            The base of floating-point arithmetic.</pre><p>
<pre>    P       (input) INT   
            The number of base BETA digits in the mantissa of a   
            floating-point value.</pre><p>
<pre>    EMIN    (input) INT   
            The minimum exponent before (gradual) underflow.</pre><p>
<pre>    IEEE    (input) INT   
            A logical flag specifying whether or not the arithmetic   
            system is thought to comply with the IEEE standard.</pre><p>
<pre>    EMAX    (output) INT   
            The largest exponent before overflow</pre><p>
<pre>    RMAX    (output) FLOAT   
            The largest machine floating-point number.</pre><p>
<pre>   =====================================================================</pre><p>
<pre>       First compute LEXP and UEXP, two powers of 2 that bound   
       <a class="el" href="slamch_8c.html#3aa069ac3980707dae1e0530f50d59e4">abs(EMIN)</a>. We then assume that EMAX + <a class="el" href="slamch_8c.html#3aa069ac3980707dae1e0530f50d59e4">abs(EMIN)</a> will sum   
       approximately to the bound that is closest to <a class="el" href="slamch_8c.html#3aa069ac3980707dae1e0530f50d59e4">abs(EMIN)</a>.   
       (EMAX is the exponent of the required number RMAX). 
</pre>     </td>
  </tr>
</table>
<a class="anchor" name="0933fc0ce8bfc358a32e1d58aab83d13"></a><!-- doxytag: member="slamch.c::slamch_" ref="0933fc0ce8bfc358a32e1d58aab83d13" args="(char *cmach)" --><p>
<table class="mdTable" cellpadding="2" cellspacing="0">
  <tr>
    <td class="mdRow">
      <table cellpadding="0" cellspacing="0" border="0">
        <tr>
          <td class="md" nowrap valign="top">double slamch_           </td>
          <td class="md" valign="top">(&nbsp;</td>
          <td class="md" nowrap valign="top">char *&nbsp;</td>
          <td class="mdname1" valign="top" nowrap> <em>cmach</em>          </td>
          <td class="md" valign="top">&nbsp;)&nbsp;</td>
          <td class="md" nowrap></td>
        </tr>
      </table>
    </td>
  </tr>
</table>
<table cellspacing="5" cellpadding="0" border="0">
  <tr>
    <td>
      &nbsp;
    </td>
    <td>

<p>
<pre>
 Purpose   
    =======</pre><p>
<pre>    SLAMCH determines single precision machine parameters.</pre><p>
<pre>    Arguments   
    =========</pre><p>
<pre>    CMACH   (input) CHARACTER*1   
            Specifies the value to be returned by SLAMCH:   
            = 'E' or 'e',   SLAMCH := eps   
            = 'S' or 's ,   SLAMCH := sfmin   
            = 'B' or 'b',   SLAMCH := base   
            = 'P' or 'p',   SLAMCH := eps*base   
            = 'N' or 'n',   SLAMCH := t   
            = 'R' or 'r',   SLAMCH := rnd   
            = 'M' or 'm',   SLAMCH := emin   
            = 'U' or 'u',   SLAMCH := rmin   
            = 'L' or 'l',   SLAMCH := emax   
            = 'O' or 'o',   SLAMCH := rmax</pre><p>
<pre>            where</pre><p>
<pre>            eps   = relative machine precision   
            sfmin = safe minimum, such that 1/sfmin does not overflow   
            base  = base of the machine   
            prec  = eps*base   
            t     = number of (base) digits in the mantissa   
            rnd   = 1.0 when rounding occurs in addition, 0.0 otherwise   
            emin  = minimum exponent before (gradual) underflow   
            rmin  = underflow threshold - base**(emin-1)   
            emax  = largest exponent before overflow   
            rmax  = overflow threshold  - (base**emax)*(1-eps)</pre><p>
<pre>   ===================================================================== 
</pre>     </td>
  </tr>
</table>
<hr size="1"><address style="align: right;"><small>Generated on Fri Aug 1 22:40:40 2008 for SuperLU by&nbsp;
<a href="http://www.doxygen.org/index.html">
<img src="doxygen.png" alt="doxygen" align="middle" border="0"></a> 1.4.6 </small></address>
</body>
</html>