---
name: "slamc5"
section: "3"
platform: "linux"
package: "liblapack-doc-man"
version: "3.5.0-4"
release: "Debian 8 (Jessie)"
platforms: ["linux"]
url: "https://new.carta.tech/slamchf77.f"
---

# slamc5(3)

Part of [slamchf77.f(3)](/slamchf77.f/3.md).

## NAME

slamchf77.f -

## SYNOPSIS

### Functions/Subroutines

real function **slamch** (CMACH)\
 **SLAMCHF77** *deprecated*  subroutine **slamc1** (BETA, T, RND, IEEE1)\
 **SLAMC1**  subroutine **slamc2** (BETA, T, RND, EPS, EMIN, RMIN, EMAX, RMAX)\
 **SLAMC2**  real function **slamc3** (A, B)\
 **SLAMC3**  subroutine **slamc4** (EMIN, START, BASE)\
 **SLAMC4**  subroutine **slamc5** (BETA, P, EMIN, IEEE, EMAX, RMAX)\
 **SLAMC5**

## Function/Subroutine Documentation

### subroutine slamc1 (integerBETA, integerT, logicalRND, logicalIEEE1)

**SLAMC1** **Purpose:**

```
 SLAMC1 determines the machine parameters given by BETA, T, RND, and
 IEEE1.
```

**Parameters:**

*BETA*

```
          The base of the machine.
```

*T*

```
          The number of ( BETA ) digits in the mantissa.
```

*RND*

```
          Specifies whether proper rounding  ( RND = .TRUE. )  or
          chopping  ( RND = .FALSE. )  occurs in addition. This may not
          be a reliable guide to the way in which the machine performs
          its arithmetic.
```

*IEEE1*

```
          Specifies whether rounding appears to be done in the IEEE
          'round to nearest' style.
```

**Author:**

LAPACK is a software package provided by Univ. of Tennessee, Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..

**Date:**

April 2012

**Further** **Details**

```
  The routine is based on the routine  ENVRON  by Malcolm and
  incorporates suggestions by Gentleman and Marovich. See
     Malcolm M. A. (1972) Algorithms to reveal properties of
        floating-point arithmetic. Comms. of the ACM, 15, 949-951.
     Gentleman W. M. and Marovich S. B. (1974) More on algorithms
        that reveal properties of floating point arithmetic units.
        Comms. of the ACM, 17, 276-277.
```

Definition at line 210 of file slamchf77.f.

### subroutine slamc2 (integerBETA, integerT, logicalRND, realEPS, integerEMIN, realRMIN, integerEMAX, realRMAX)

**SLAMC2** **Purpose:**

```
 SLAMC2 determines the machine parameters specified in its argument
 list.
```

**Author:**

LAPACK is a software package provided by Univ. of Tennessee, Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..

**Date:**

April 2012

**Parameters:**

*BETA*

```
          The base of the machine.
```

*T*

```
          The number of ( BETA ) digits in the mantissa.
```

*RND*

```
          Specifies whether proper rounding  ( RND = .TRUE. )  or
          chopping  ( RND = .FALSE. )  occurs in addition. This may not
          be a reliable guide to the way in which the machine performs
          its arithmetic.
```

*EPS*

```
          The smallest positive number such that
             fl( 1.0 - EPS ) .LT. 1.0,
          where fl denotes the computed value.
```

*EMIN*

```
          The minimum exponent before (gradual) underflow occurs.
```

*RMIN*

```
          The smallest normalized number for the machine, given by
          BASE**( EMIN - 1 ), where  BASE  is the floating point value
          of BETA.
```

*EMAX*

```
          The maximum exponent before overflow occurs.
```

*RMAX*

```
          The largest positive number for the machine, given by
          BASE**EMAX * ( 1 - EPS ), where  BASE  is the floating point
          value of BETA.
```

**Further** **Details**

```
  The computation of  EPS  is based on a routine PARANOIA by
  W. Kahan of the University of California at Berkeley.
```

Definition at line 423 of file slamchf77.f.

### real function slamc3 (realA, realB)

**SLAMC3** **Purpose:**

```
 SLAMC3  is intended to force  A  and  B  to be stored prior to doing
 the addition of  A  and  B ,  for use in situations where optimizers
 might hold one of these in a register.
```

**Parameters:**

*A* \
 *B*

```
          The values A and B.
```

Definition at line 646 of file slamchf77.f.

### subroutine slamc4 (integerEMIN, realSTART, integerBASE)

**SLAMC4** **Purpose:**

```
 SLAMC4 is a service routine for SLAMC2.
```

**Parameters:**

*EMIN*

```
          The minimum exponent before (gradual) underflow, computed by
          setting A = START and dividing by BASE until the previous A
          can not be recovered.
```

*START*

```
          The starting point for determining EMIN.
```

*BASE*

```
          The base of the machine.
```

Definition at line 693 of file slamchf77.f.

### subroutine slamc5 (integerBETA, integerP, integerEMIN, logicalIEEE, integerEMAX, realRMAX)

**SLAMC5** **Purpose:**

```
 SLAMC5 attempts to compute RMAX, the largest machine floating-point
 number, without overflow.  It assumes that EMAX + abs(EMIN) 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,
 EMAX = 28718).  It will also fail if the value supplied for EMIN is
 too large (i.e. too close to zero), probably with overflow.
```

**Parameters:**

*BETA*

```
          The base of floating-point arithmetic.
```

*P*

```
          The number of base BETA digits in the mantissa of a
          floating-point value.
```

*EMIN*

```
          The minimum exponent before (gradual) underflow.
```

*IEEE*

```
          A logical flag specifying whether or not the arithmetic
          system is thought to comply with the IEEE standard.
```

*EMAX*

```
          The largest exponent before overflow
```

*RMAX*

```
          The largest machine floating-point number.
```

Definition at line 801 of file slamchf77.f.

### real function slamch (characterCMACH)

**SLAMCHF77** deprecated

**Purpose:**

```
 SLAMCH determines single precision machine parameters.
```

**Parameters:**

*CMACH*

```
          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
          where
          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)
```

**Author:**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date:**

April 2012

Definition at line 68 of file slamchf77.f.

## Author

Generated automatically by Doxygen for LAPACK from the source code.
