---
name: "ACE_Stats"
section: "3"
platform: "linux"
package: "libace-doc"
version: "5.0.7-4"
release: "Debian 2.2 (Potato)"
platforms: ["linux"]
url: "https://new.carta.tech/ACE_Stats"
---

# ACE\_Stats(3)

Provides simple statistical analysis.

## NAME

ACE\_Stats -  Provides simple statistical analysis.

## SYNOPSIS

```
#include <ace/Stats.h>
class ACE_Stats
{
  public:
    ACE_Stats (void);
    int sample (const ACE_INT32 value);
    ACE_UINT32 samples (void) const;
    ACE_INT32 min_value (void) const;
    ACE_INT32 max_value (void) const;
    void mean (
        ACE_Stats_Value &mean,
        const ACE_UINT32 scale_factor = 1
        );
    int std_dev (
        ACE_Stats_Value &std_dev,
        const ACE_UINT32 scale_factor = 1
        );
    int print_summary (
        const u_int precision,
        const ACE_UINT32 scale_factor = 1,
        FILE * = stdout
        ) const;
    void reset (void);
    static void quotient (
        const ACE_UINT64 dividend,
        const ACE_UINT32 divisor,
        ACE_Stats_Value &quotient
        );
    static void quotient (
        const ACE_Stats_Value &dividend,
        const ACE_UINT32 divisor,
        ACE_Stats_Value &quotient
        );
    static void square_root (
        const ACE_UINT64 n,
        ACE_Stats_Value &square_root
        );
    void dump (void) const;
  private:
    u_int overflow_;
    ACE_UINT32 number_of_samples_;
    ACE_INT32 min_;
    ACE_INT32 max_;
    ACE_Unbounded_Queue <ACE_INT32> samples_;
};
```

## DESCRIPTION

Simple statistical analysis package.  Prominent features are: 1) It does not use any floating point arithmetic. 2) It handles positive and/or negative sample values.  The\
    sample value type is ACE\_INT32. 3) It uses 64 bit unsigned, but not 64 bit signed, quantities\
    internally. 4) It checks for overflow of internal state. 5) It has no static variables of other than built-in types.

Example usage:\
   ACE\_Stats stats;\
   for (u\_int i = 0; i  n; ++i)\
     {\
       const ACE\_UINT32 sample = /\* ... \*/;\
       stats.sample (sample);\
     }\
   stats.print\_summary (3);

## PUBLIC MEMBERS

```
ACE_Stats (void);
```

Default constructor.

```
int sample (const ACE_INT32 value);
```

Provide a new sample.  Returns 0 on success, -1 if it fails due to running out of memory, or to rolling over of the sample count.

```
ACE_UINT32 samples (void) const;
```

Access the number of samples provided so far.

```
ACE_INT32 min_value (void) const;
```

Value of the minimum sample provided so far.

```
ACE_INT32 max_value (void) const;
```

Value of the maximum sample provided so far.

```
void mean (ACE_Stats_Value &mean, const ACE_UINT32 scale_factor = 1);
```

Access the mean of all samples provided so far.  The fractional part is to the specified number of digits.  E.g., 3 fractional digits specifies that the fractional part is in thousandths.

```
int std_dev (
    ACE_Stats_Value &std_dev,
    const ACE_UINT32 scale_factor = 1
    );
```

Access the standard deviation, whole and fractional parts.  See description of mean method for argument descriptions.

```
int print_summary (
    const u_int precision,
    const ACE_UINT32 scale_factor = 1,
    FILE * = stdout
    ) const;
```

Print summary statistics.  If scale\_factor is not 1, then the results are divided by it, i.e., each of the samples is scaled down by it.  If internal overflow is reached with the specified scale factor, it successively tries to reduce it.  Returns -1 if there is overflow even with a 0 scale factor.

```
void reset (void);
```

Initialize internal state.

```
static void quotient (
    const ACE_UINT64 dividend,
    const ACE_UINT32 divisor,
    ACE_Stats_Value &quotient
    );
```

Utility division function, for ACE\_UINT64 dividend.

```
static void quotient (
    const ACE_Stats_Value &dividend,
    const ACE_UINT32 divisor,
    ACE_Stats_Value &quotient
    );
```

Utility division function, for ACE\_Stats\_Value dividend.

```
static void square_root (
    const ACE_UINT64 n,
    ACE_Stats_Value &square_root
    );
```

Sqrt function, which uses an oversimplified version of Newton's method.  It's not fast, but it doesn't require floating point support.

```
void dump (void) const;
```

Print summary statistics to stdout.

## PRIVATE MEMBERS

```
u_int overflow_;
```

Internal indication of whether there has been overflow.  Contains the errno corresponding to the cause of overflow.

```
ACE_UINT32 number_of_samples_;
```

Number of samples.

```
ACE_INT32 min_;
```

Minimum sample value.

```
ACE_INT32 max_;
```

Maximum sample value.

```
ACE_Unbounded_Queue <ACE_INT32> samples_;
```

The samples.

## AUTHORS

David L. Levine

## LIBRARY

ace