{"id":668,"date":"2025-05-12T21:06:41","date_gmt":"2025-05-12T19:06:41","guid":{"rendered":"https:\/\/renor.it\/a-descriptive-statistics-class-in-php\/"},"modified":"2025-12-20T15:53:57","modified_gmt":"2025-12-20T14:53:57","slug":"a-descriptive-statistics-class-in-php","status":"publish","type":"post","link":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/","title":{"rendered":"A Descriptive Statistics Class in PHP"},"content":{"rendered":"\n

In the world of software development, data analysis is becoming increasingly central. With the advent of artificial intelligence in the consumer market, many now use it to analyze statistical data as well. However, in many cases, the use of this technology is not required and is actually less efficient than a solid algorithm designed to take input data and return output data in a \u201cblack-box\u201d manner. <\/p>\n\n

Artificial intelligence is now seen by many entrepreneurs as a trend, but it should only be used where it truly adds value. Speaking of efficiency, using AI to calculate a mean, a median, or a mode is not only like using a bazooka to kill a couple of flies, but it can also turn out to be slower, considering the inference times, compared to a finite state algorithm. <\/p>\n\n

Even in contexts that are not strictly scientific or academic, knowing the fundamentals of descriptive statistics can prove extremely useful: from generating automated reports, to monitoring an application\u2019s performance, and even to building dashboards or analytical tools. <\/p>\n\n

In this article, we will build a PHP class that calculates the main descriptive statistical indicators\u2014such as mean, median, mode, variance, standard deviation, quartiles, and more\u2014from scratch, without relying on external libraries. The code will be clean, reusable, and ready to be transformed into a Composer package, which will be the subject of a follow-up article. <\/p>\n\n

Designing a simple yet extensible class<\/h2>\n\n

To build a useful and easily integrable descriptive statistics class, we will adopt an object-oriented structure aligned with SOLID principles, avoiding external dependencies and ensuring the possibility of future extension (e.g., support for associative datasets or reading from CSV files). <\/p>\n\n

The class will be designed to operate on arrays of numerical values and efficiently compute the main statistical indicators. The goal is to provide a simple interface. <\/p>\n\n

First, let\u2019s create a new repository on GitHub, which you can find at the following link:https:\/\/github.com\/thesimon82\/descriptive-statistics-php<\/a><\/p>\n\n

Let\u2019s start implementing the methods.<\/p>\n\n

The project structure should be as follows: <\/p>\n\n

<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
descriptive-statistics-php\/<\/span><\/span>\n\u251c\u2500 composer<\/span>.<\/span>json<\/span><\/span>\n\u251c\u2500 composer<\/span>.<\/span>lock<\/span><\/span>\n\u251c\u2500 phpunit<\/span>.<\/span>xml<\/span><\/span>\n\u251c\u2500 examples\/<\/span><\/span>\n\u2502  \u2514\u2500 geometric_mean_demo<\/span>.<\/span>php<\/span><\/span>\n\u2502  \u2514\u2500 harmonic_mean_demo<\/span>.<\/span>php<\/span><\/span>\n\u2502  \u2514\u2500 iqr_demo<\/span>.<\/span>php<\/span><\/span>\n\u2502  \u2514\u2500 mad_demo<\/span>.<\/span>php<\/span><\/span>\n\u2502  \u2514\u2500 mean_demo<\/span>.<\/span>php<\/span><\/span>\n\u2502  \u2514\u2500 median_demo<\/span>.<\/span>php<\/span><\/span>\n\u2502  \u2514\u2500 min_max_demo<\/span>.<\/span>php<\/span><\/span>\n\u2502  \u2514\u2500 mode_demo<\/span>.<\/span>php<\/span><\/span>\n\u2502  \u2514\u2500 percentile_demo<\/span>.<\/span>php<\/span><\/span>\n\u2502  \u2514\u2500 range_demo<\/span>.<\/span>php<\/span><\/span>\n\u2502  \u2514\u2500 standard_deviation_demo<\/span>.<\/span>php<\/span><\/span>\n\u2502  \u2514\u2500 trimmed_mean_demo<\/span>.<\/span>php<\/span><\/span>\n\u2502  \u2514\u2500 variance_demo<\/span>.<\/span>php<\/span><\/span>\n\u251c\u2500 src\/<\/span><\/span>\n\u2502  \u2514\u2500 DescriptiveStats<\/span>.<\/span>php<\/span><\/span>\n\u251c\u2500 tests\/<\/span><\/span>\n\u2502  \u2514\u2500 DescriptiveStatsTest<\/span>.<\/span>php<\/span><\/span>\n\u2514\u2500 vendor\/<\/span><\/span>\n    \u2514\u2500 autoload<\/span>.<\/span>php<\/span><\/span><\/code><\/pre><\/div>\n\n
As you can see, I have also included a folder for adding tests on the class methods (optional) using PHPUnit. The phpunit.xml file defines the test folder and the PHPUnit sources, which must be installed via Composer from the Packagist repository phpunit\/phpunit<\/code>, adding it as a development dependency using the command composer require --dev phpunit\/phpunit ^10<\/code>. <\/p>\n\n
Mean<\/h2>\n\n
The arithmetic mean<\/strong> (or average) of a set of \"n\" numerical observations \"x_1, x_2, \dots, x_n\" is obtained by summing all the values and dividing the result by the total number of observations. Formally, it is written as: <\/p>\n\n
\"\bar{x} \;=\; \frac{1}{n} \sum_{i=1}^{n} x_i\"<\/p>\n\n
where \"\bar{x}\" represents the arithmetic mean, \"n\" is the sample size, and \"\sum_{i=1}^{n} x_i\" indicates the sum of all observations. This measure provides a concise indication of the central tendency of the data, although it is sensitive to the presence of outliers, which can cause it to deviate significantly from the actual \u201ccenter\u201d of the distribution. <\/p>\n\n
Let\u2019s implement this method in our class. DescriptiveStats.php<\/code><\/p>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
<?php<\/span><\/span>\n\ndeclare<\/span>(strict_types=<\/span>1<\/span>);<\/span><\/span>\n\nnamespace<\/span> <\/span>Renor\\Statistics<\/span>;<\/span><\/span>\n\n\/**<\/span><\/span>\n * Class DescriptiveStats<\/span><\/span>\n *<\/span><\/span>\n * A lightweight class to perform basic descriptive statistics on numeric datasets.<\/span><\/span>\n *\/<\/span><\/span>\nclass<\/span> <\/span>DescriptiveStats<\/span><\/span>\n{<\/span><\/span>\n    <\/span>\/**<\/span><\/span>\n     * <\/span>@var<\/span> <\/span>float[]<\/span> Filtered and normalized numeric dataset.<\/span><\/span>\n     *\/<\/span><\/span>\n    <\/span>private<\/span> <\/span>array<\/span> <\/span>$data<\/span>;<\/span><\/span>\n\n    <\/span>\/**<\/span><\/span>\n     * Main constructor.<\/span><\/span>\n     *<\/span><\/span>\n     * <\/span>@param<\/span> <\/span>array<\/span> $data An array containing the numeric values to be analyzed.<\/span><\/span>\n     * <\/span>@throws<\/span> <\/span>\\InvalidArgumentException<\/span> If the array is empty or contains no numeric values.<\/span><\/span>\n     *\/<\/span><\/span>\n    <\/span>public<\/span> <\/span>function<\/span> <\/span>__construct<\/span>(<\/span>array<\/span> <\/span>$data<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>\/\/ Filter only numeric values (int or float) and reset array keys<\/span><\/span>\n        <\/span>$filtered<\/span> = <\/span>array_filter<\/span>(<\/span>$data<\/span>, <\/span>'is_numeric'<\/span>);<\/span><\/span>\n        <\/span>$this<\/span>-><\/span>data<\/span> = <\/span>array_values<\/span>(<\/span>$filtered<\/span>);<\/span><\/span>\n\n        <\/span>if<\/span> (<\/span>count<\/span>(<\/span>$this<\/span>-><\/span>data<\/span>) === <\/span>0<\/span>) {<\/span><\/span>\n            <\/span>throw<\/span> <\/span>new<\/span> <\/span>\\InvalidArgumentException<\/span>(<\/span>'The dataset must contain at least one numeric value.'<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>\/**<\/span><\/span>\n     * Calculates the arithmetic mean of the dataset.<\/span><\/span>\n     *<\/span><\/span>\n     * <\/span>@return<\/span> <\/span>float<\/span> The arithmetic mean.<\/span><\/span>\n     *\/<\/span><\/span>\n    <\/span>public<\/span> <\/span>function<\/span> <\/span>mean<\/span>(): <\/span>float<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>return<\/span> <\/span>array_sum<\/span>(<\/span>$this<\/span>-><\/span>data<\/span>) \/ <\/span>count<\/span>(<\/span>$this<\/span>-><\/span>data<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n
As you can see, we have declared strict_types. This directive enforces PHP to avoid automatic type coercion, which is essential when we want full control over data types.   <\/p>\n\n
Since we will accept the data as an array of values, we declare a private property of the class private array $data<\/code>.<\/p>\n\n
In the class constructor, we handle retrieving the data passed when instantiating the class to create a new object, verifying that the contents of the array $data<\/code> are numeric, and we place the values inside the property $this->data<\/code>.<\/p>\n\n
In the mean()<\/code> method, we implement the mathematical formula for the mean: we sum all the elements of the passed array and divide by the number of elements, returning the result. <\/p>\n\n
Median<\/h2>\n\n
The median represents the central value of an ordered set of observations and divides the sample into two halves of equal size. Given a series of \"n\" values \"x_1, x_2, \dots, x_n\" such that \"x_1 \le x_2 \le \dots \le x_n\": <\/p>\n\n
    \n
  • If \"n\" is odd, the median is simply the element in position \"\frac{n+1}{2}\": \"\text{Mediana} = x_{\frac{n+1}{2}}\"<\/li>\n\n\n\n
  • If \"n\" is even, the median is the arithmetic mean of the two central elements: \"\text{Mediana} = \frac{x_{\frac{n}{2}} + x_{\frac{n}{2}+1}}{2}\"<\/li>\n<\/ul>\n\n
    Unlike the arithmetic mean, the median is robust to outliers, as it depends only on the ordering of the data and not on their magnitude. <\/p>\n\n
    <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
     <\/span>\/**<\/span><\/span>\n     * Calculates the median (50th percentile) of the dataset.<\/span><\/span>\n     *<\/span><\/span>\n     * <\/span>@return<\/span> <\/span>float<\/span> The median value.<\/span><\/span>\n     *\/<\/span><\/span>\n    <\/span>public<\/span> <\/span>function<\/span> <\/span>median<\/span>(): <\/span>float<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>\/\/ Clone and sort the dataset to avoid mutating the original array<\/span><\/span>\n        <\/span>$sorted<\/span> = <\/span>$this<\/span>-><\/span>data<\/span>;<\/span><\/span>\n        <\/span>sort<\/span>(<\/span>$sorted<\/span>, SORT_NUMERIC);<\/span><\/span>\n\n        <\/span>$count<\/span> = <\/span>count<\/span>(<\/span>$sorted<\/span>);<\/span><\/span>\n        <\/span>$mid<\/span>   = <\/span>intdiv<\/span>(<\/span>$count<\/span>, <\/span>2<\/span>);<\/span><\/span>\n\n        <\/span>\/\/ If the count is odd, return the middle value<\/span><\/span>\n        <\/span>if<\/span> (<\/span>$count<\/span> % <\/span>2<\/span> === <\/span>1<\/span>) {<\/span><\/span>\n            <\/span>return<\/span> (<\/span>float<\/span>) <\/span>$sorted<\/span>[<\/span>$mid<\/span>];<\/span><\/span>\n        }<\/span><\/span>\n\n        <\/span>\/\/ If even, return the average of the two central values<\/span><\/span>\n        <\/span>return<\/span> (<\/span>$sorted<\/span>[<\/span>$mid<\/span> - <\/span>1<\/span>] + <\/span>$sorted<\/span>[<\/span>$mid<\/span>]) \/ <\/span>2.0<\/span>;<\/span><\/span>\n    }<\/span><\/span><\/code><\/pre><\/div>\n\n
    In this method, I retrieve the data and sort it. We get the size and calculate the central index using integer division. For example, if we have 7 elements, intdiv(7,2)<\/code> returns 3, which corresponds to the fourth position (remember that arrays in PHP are zero-based!). If the number of values is odd, there is a single perfectly central element, and it is returned. In the case of an even number of values, however, there is not just one central value but two: the ones in positions $mid - 1<\/code> and $mid<\/code>. By definition, the median is the arithmetic mean of these two values. We therefore sum the central elements and divide by 2.0 (using decimal notation to force floating-point division), which returns a float result. This way, the method returns the fiftieth percentile of the sample without modifying the original dataset and in accordance with the statistical definition for both odd and even-length series.        <\/p>\n\n
    Mode<\/h2>\n\n
    After the mean and the median, the third most commonly used indicator in descriptive statistics is the mode, that is, the value or values that occur most frequently within a set of observations. If we denote by \"f(x)\" the absolute frequency of a value \"x\" in the sample, the mode is obtained as: <\/p>\n\n
    \"\text{Moda} = \operatorname*{arg\,max}_{x}\; f(x)\".<\/p>\n\n
    We can distinguish, based on the input data series:<\/p>\n\n
      \n
    • Unimodal series when only one value has the highest frequency<\/li>\n\n\n\n
    • Multimodal series when two or more values share the highest frequency<\/li>\n\n\n\n
    • Series without a mode when all the values in the series appear only once each<\/li>\n<\/ul>\n\n
      The mode is particularly useful when the data are categorical or when one wants to highlight concentration around certain integer values. Unlike the mean and the median, it does not measure central tendency but rather the value or values that occur most frequently in the series. It is no coincidence that when a clothing item is \u201cin fashion\u201d it is because, compared to other items in a sales series, it turns out to be the most sold and therefore \u201cthe one most in fashion.\u201d   <\/p>\n\n
      Let\u2019s therefore add the method to our class:<\/p>\n\n
      <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
      \/**<\/span><\/span>\n * Returns the mode(s) of the dataset.<\/span><\/span>\n *<\/span><\/span>\n * If the dataset is multimodal, an array with all modal values is returned.<\/span><\/span>\n * If every value occurs only once, an empty array is returned (no mode).<\/span><\/span>\n *<\/span><\/span>\n * <\/span>@return<\/span> <\/span>float[]<\/span> list of modal values<\/span><\/span>\n *\/<\/span><\/span>\npublic<\/span> <\/span>function<\/span> <\/span>mode<\/span>(): <\/span>array<\/span><\/span>\n{<\/span><\/span>\n    <\/span>\/\/ Build a frequency table: value => occurrences<\/span><\/span>\n    <\/span>$frequencies<\/span> = <\/span>array_count_values<\/span>(<\/span>$this<\/span>-><\/span>data<\/span>);<\/span><\/span>\n\n    <\/span>\/\/ Determine the highest frequency<\/span><\/span>\n    <\/span>$maxFrequency<\/span> = <\/span>max<\/span>(<\/span>$frequencies<\/span>);<\/span><\/span>\n\n    <\/span>\/\/ If every value appears only once, there is no mode<\/span><\/span>\n    <\/span>if<\/span> (<\/span>$maxFrequency<\/span> === <\/span>1<\/span>) {<\/span><\/span>\n        <\/span>return<\/span> [];<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>\/\/ Collect all values that share the highest frequency<\/span><\/span>\n    <\/span>$modes<\/span> = [];<\/span><\/span>\n    <\/span>foreach<\/span> (<\/span>$frequencies<\/span> as <\/span>$value<\/span> => <\/span>$count<\/span>) {<\/span><\/span>\n        <\/span>if<\/span> (<\/span>$count<\/span> === <\/span>$maxFrequency<\/span>) {<\/span><\/span>\n            <\/span>\/\/ Cast to float so that return type is consistent<\/span><\/span>\n            <\/span>$modes<\/span>[] = (<\/span>float<\/span>) <\/span>$value<\/span>;<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>sort<\/span>(<\/span>$modes<\/span>, SORT_NUMERIC); <\/span>\/\/ return modes in ascending order<\/span><\/span>\n    <\/span>return<\/span> <\/span>$modes<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n
      array_count_values()<\/code> It scans the entire dataset and returns an associative array where the key<\/strong> is the observed value and the value<\/strong> is the number of times it occurs. This is a quick way to calculate \"f(x)\" for each \"x\".With max($frequencies)<\/code>, we obtain the highest number of occurrences present in the table; this corresponds to the value of \"\max f(x)\" in the mathematical definition.If the maximum frequency is 1, it means that each observation is unique. In this case, the method returns an empty array to indicate that no modal value exists.We iterate over the frequency table: for each key whose count equals the maximum frequency, we add that value (cast to float) to the array $modes<\/code>. In this way, all<\/strong> modal values are included in the case of multimodality.Before returning the result, sort($modes, SORT_NUMERIC)<\/code> ensures that the modes are sorted in ascending order, making the output more predictable.   <\/p>\n\n
      In this way, we have covered all possible scenarios: unimodal, multimodal, and without a mode. <\/p>\n\n
      Geometric mean<\/h2>\n\n
      The geometric mean<\/strong> is the most appropriate measure of central tendency when the data represent growth rates<\/em> or ratios<\/em> (for example, percentage returns, variation indices, logarithmic scales).<\/p>\n\n
      Given a series of \"n\" strictly positive values<\/strong> \"x_1, x_2, \dots, x_n\", the geometric mean \"G\" is defined as:<\/p>\n\n
      \"G \;=\; \Bigl( \prod_{i=1}^{n} x_i \Bigr)^{\frac{1}{n}}\"<\/p>\n\n
      or, in a numerically more stable logarithmic form:<\/p>\n\n
      \"\ln G \;=\; \frac{1}{n} \sum_{i=1}^{n} \ln x_i\".<\/p>\n\n
      This quantity corresponds to the \u201caverage\u201d growth factor which, applied n times in sequence, yields the same result as the actual product of the values.<\/p>\n\n
      <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
      \/**<\/span><\/span>\n * Calculates the geometric mean of the dataset.<\/span><\/span>\n *<\/span><\/span>\n * <\/span>@throws<\/span> <\/span>\\DomainException<\/span> If any value is zero or negative.<\/span><\/span>\n * <\/span>@return<\/span> <\/span>float<\/span> The geometric mean.<\/span><\/span>\n *\/<\/span><\/span>\npublic<\/span> <\/span>function<\/span> <\/span>geometricMean<\/span>(): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>\/\/ The geometric mean is defined only for strictly positive numbers.<\/span><\/span>\n    <\/span>foreach<\/span> (<\/span>$this<\/span>-><\/span>data<\/span> as <\/span>$value<\/span>) {<\/span><\/span>\n        <\/span>if<\/span> (<\/span>$value<\/span> <= <\/span>0<\/span>) {<\/span><\/span>\n            <\/span>throw<\/span> <\/span>new<\/span> <\/span>\\DomainException<\/span>(<\/span>'Geometric mean requires all values to be greater than zero.'<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>\/\/ Use logarithms for numerical stability: exp( (1\/n) * sum(log(x_i)) )<\/span><\/span>\n    <\/span>$logSum<\/span> = <\/span>array_sum<\/span>(<\/span>array_map<\/span>(<\/span>'log'<\/span>, <\/span>$this<\/span>-><\/span>data<\/span>));<\/span><\/span>\n    <\/span>return<\/span> <\/span>exp<\/span>(<\/span>$logSum<\/span> \/ <\/span>count<\/span>(<\/span>$this<\/span>-><\/span>data<\/span>));<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n
      Since the geometric mean is only defined for positive numbers, the method scans the dataset and throws a DomainException if it encounters values \u2264 0. This prevents mathematically incorrect (or complex) results.Instead of directly calculating the product (which could easily overflow), we convert each value using log()<\/code>, sum the logarithms, and divide by \"n\". Based on the properties of logarithms:   \"\ln\!\Bigl(\prod x_i\Bigr) \;=\; \sum \ln x_i\"By applying exp()<\/code> to the average of the logarithms, we obtain the geometric mean.\"G \;=\; \exp\!\Bigl(\tfrac{1}{n}\sum \ln x_i\Bigr)\"<\/p>\n\n
      Harmonic mean<\/h2>\n\n
      The harmonic mean<\/strong> is the most appropriate measure of central tendency when the data represent speeds, ratios, or fractions<\/strong>\u2014for example, kilometers per hour traveled at different paces, average cost per unit, or average return on investments calculated as \u201cunits per euro.\u201d<\/p>\n\n
      Given a series of \"n\" positive values \"x_1, x_2, \dots, x_n\" (no value can be zero, as it would appear in the denominator), the harmonic mean \"H\" is defined as:\"H \;=\; \frac{n}{\displaystyle\sum_{i=1}^{n} \frac{1}{x_i}}\"<\/p>\n\n
      In other words, it is calculated as the inverse of the arithmetic mean<\/strong> of the reciprocals. Compared to the arithmetic mean, the harmonic mean gives more weight to smaller values<\/strong>: it is therefore valuable when one wishes to strongly penalize poorer performances (e.g., the average time to travel one kilometer over multiple segments at different speeds). <\/p>\n\n
      <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
      \/**<\/span><\/span>\n * Calculates the harmonic mean of the dataset.<\/span><\/span>\n *<\/span><\/span>\n * <\/span>@throws<\/span> <\/span>\\DomainException<\/span> If any value is zero or negative.<\/span><\/span>\n * <\/span>@return<\/span> <\/span>float<\/span> The harmonic mean.<\/span><\/span>\n *\/<\/span><\/span>\npublic<\/span> <\/span>function<\/span> <\/span>harmonicMean<\/span>(): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>\/\/ Harmonic mean is defined only for strictly positive numbers.<\/span><\/span>\n    <\/span>foreach<\/span> (<\/span>$this<\/span>-><\/span>data<\/span> as <\/span>$value<\/span>) {<\/span><\/span>\n        <\/span>if<\/span> (<\/span>$value<\/span> <= <\/span>0<\/span>) {<\/span><\/span>\n            <\/span>throw<\/span> <\/span>new<\/span> <\/span>\\DomainException<\/span>(<\/span>'Harmonic mean requires all values to be greater than zero.'<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>$inverseSum<\/span> = <\/span>array_sum<\/span>(<\/span>array_map<\/span>(<\/span><\/span>\n        <\/span>static<\/span> <\/span>fn<\/span> (<\/span>float<\/span> <\/span>$v<\/span>): <\/span>float<\/span> => <\/span>1.0<\/span> \/ <\/span>$v<\/span>,<\/span><\/span>\n        <\/span>$this<\/span>-><\/span>data<\/span><\/span>\n    ));<\/span><\/span>\n\n    <\/span>return<\/span> <\/span>count<\/span>(<\/span>$this<\/span>-><\/span>data<\/span>) \/ <\/span>$inverseSum<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n
      First, a domain check is performed: any value less than or equal to zero triggers a DomainException, otherwise the result would be undefined or become infinite. Then, a sum of the reciprocals is computed: array_map()<\/code> calculates the reciprocal of each element, array_sum()<\/code> sums them.The direct formula divides the number of observations \"n\" by the obtained sum, according to the mathematical definition.  <\/p>\n\n
      Truncated mean (or trimmed mean)<\/h2>\n\n
      When a sample contains extreme outliers<\/strong> that risk distorting the arithmetic mean, an elegant solution is the truncated mean<\/strong> (or trimmed mean<\/em>).<\/p>\n\n
      A percentage \"p\"% (typically 5% or 10%) is chosen, the sample is sorted, and the first \"k\" smallest and the last \"k\" largest observations are discarded<\/strong>, where:<\/p>\n\n
      \"\bar{x}{\text{trim}} \;=\; \frac{1}{\,n-2k\,} \sum{i=k+1}^{\,n-k} x_{(i)} \".This way, a measure of central tendency is obtained that is more robust<\/strong> than the arithmetic mean but less drastic than the median.<\/p>\n\n
      <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
      \/**<\/span><\/span>\n * Calculates the trimmed mean of the dataset.<\/span><\/span>\n *<\/span><\/span>\n * <\/span>@param<\/span> <\/span>float<\/span> $percent Percentage (0\u201350) of data to trim at each tail.<\/span><\/span>\n * <\/span>@throws<\/span> <\/span>\\DomainException<\/span> If $percent is out of range or removes all data.<\/span><\/span>\n * <\/span>@return<\/span> <\/span>float<\/span> The trimmed mean.<\/span><\/span>\n *\/<\/span><\/span>\npublic<\/span> <\/span>function<\/span> <\/span>trimmedMean<\/span>(<\/span>float<\/span> <\/span>$percent<\/span>): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>if<\/span> (<\/span>$percent<\/span> < <\/span>0.0<\/span> || <\/span>$percent<\/span> >= <\/span>50.0<\/span>) {<\/span><\/span>\n        <\/span>throw<\/span> <\/span>new<\/span> <\/span>\\DomainException<\/span>(<\/span>'Percent must be in the range 0 <= p < 50.'<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>$count<\/span> = <\/span>count<\/span>(<\/span>$this<\/span>-><\/span>data<\/span>);<\/span><\/span>\n    <\/span>if<\/span> (<\/span>$count<\/span> < <\/span>3<\/span>) {<\/span><\/span>\n        <\/span>\/\/ Too few values to trim meaningfully; fall back to arithmetic mean<\/span><\/span>\n        <\/span>return<\/span> <\/span>$this<\/span>-><\/span>mean<\/span>();<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>\/\/ Clone and sort to preserve original order<\/span><\/span>\n    <\/span>$sorted<\/span> = <\/span>$this<\/span>-><\/span>data<\/span>;<\/span><\/span>\n    <\/span>sort<\/span>(<\/span>$sorted<\/span>, SORT_NUMERIC);<\/span><\/span>\n\n    <\/span>\/\/ Number of elements to trim from each end<\/span><\/span>\n    <\/span>$k<\/span> = (<\/span>int<\/span>) <\/span>floor<\/span>(<\/span>$count<\/span> * <\/span>$percent<\/span> \/ <\/span>100.0<\/span>);<\/span><\/span>\n\n    <\/span>\/\/ Ensure at least one value remains<\/span><\/span>\n    <\/span>if<\/span> (<\/span>$k<\/span> * <\/span>2<\/span> >= <\/span>$count<\/span>) {<\/span><\/span>\n        <\/span>throw<\/span> <\/span>new<\/span> <\/span>\\DomainException<\/span>(<\/span>'Trim percentage removes all data.'<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>$trimmed<\/span> = <\/span>array_slice<\/span>(<\/span>$sorted<\/span>, <\/span>$k<\/span>, <\/span>$count<\/span> - <\/span>2<\/span> * <\/span>$k<\/span>);<\/span><\/span>\n\n    <\/span>return<\/span> <\/span>array_sum<\/span>(<\/span>$trimmed<\/span>) \/ <\/span>count<\/span>(<\/span>$trimmed<\/span>);<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n
      The method begins by verifying that the chosen trimming percentage makes sense: it must be greater than or equal to zero and strictly less than fifty, otherwise an exception is thrown; if, for example, we were to request the removal of 60% of the data from each tail, there would be nothing left to average.<\/p>\n\n
      If the sample contains fewer than three observations, the function considers trimming meaningless and simply returns the arithmetic mean: with two values, removing even one would eliminate half the data, while with only one there is nothing to trim.<\/p>\n\n
      The process then proceeds by cloning<\/strong> the original array and sorting<\/strong> it in ascending order; cloning preserves the order in which the data was provided to the object, while sorting is essential because trimming is applied starting from the extremes of the distribution.<\/p>\n\n
      The number of elements to discard at each tail, denoted by \"k\", is obtained by multiplying the sample size by the requested percentage and rounding down; for example, if we have ten values and want a 10% trimmed mean, we will remove one element from the beginning and one from the end.<\/p>\n\n
      Before proceeding, the method checks that \u201ctwice \"k\"\u201d is not equal to or greater than the length of the array: if it were, the trimming would remove all the data and the mean would no longer make sense; in such case, an additional exception is thrown.<\/p>\n\n
      Once this check is passed, array_slice()<\/code> extracts the central portion that remains after discarding the \"k\" smallest and \"k\" largest values; the arithmetic mean is then calculated on this subset, which is precisely the desired trimmed mean<\/strong>.<\/p>\n\n
      The function thus returns a measure of central tendency that is more robust<\/strong> than the classic mean: the outliers, removed before the calculation, can no longer pull the result toward extreme values.<\/p>\n\n
      Range<\/h2>\n\n
      The range<\/strong> is the simplest measure of dispersion: it indicates the total spread of the observed values, that is, the distance between the minimum and maximum extremes of the sample. If we denote <\/p>\n\n
      \"x_{\min} = \min(x_1,\dots,x_n) \quad\text{e}\quad x_{\max} = \max(x_1,\dots,x_n)\",<\/p>\n\n
      then the range \"R\" is defined as<\/p>\n\n
      \"R = x_{\max} \;-\; x_{\min}\".<\/p>\n\n
      Although it is sensitive to outliers (the same value that affects the maximum or minimum also affects the range), this measure provides an immediate indication of the distribution\u2019s spread<\/strong> and is often reported alongside the mean or median to give a quick overview of overall dispersion.<\/p>\n\n
      <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
      \/**<\/span><\/span>\n * Calculates the range (max \u2013 min) of the dataset.<\/span><\/span>\n *<\/span><\/span>\n * <\/span>@return<\/span> <\/span>float<\/span> The range of the data.<\/span><\/span>\n *\/<\/span><\/span>\npublic<\/span> <\/span>function<\/span> <\/span>range<\/span>(): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>\/\/ min() e max() sono O(n) ma il dataset \u00e8 gi\u00e0 in memoria: soluzione lineare<\/span><\/span>\n    <\/span>return<\/span> <\/span>max<\/span>(<\/span>$this<\/span>-><\/span>data<\/span>) - <\/span>min<\/span>(<\/span>$this<\/span>-><\/span>data<\/span>);<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n
      As can be seen, the method is very straightforward. It invokes the native PHP functions max()<\/code> and min()<\/code>, which each perform a single linear scan of the array to identify the largest and smallest values, respectively. Subtracting the minimum from the maximum yields the total spread of the sample; the result is returned as a float, consistent with the other methods in the class.   <\/p>\n\n
      Quartiles and interquartile range (IQR)<\/h2>\n\n
      To describe the dispersion of a sample more robustly than with the simple range, quartiles<\/strong> are used:<\/p>\n\n
        \n
      • \"Q_1\" \u2013 25th percentile (first quartile)<\/li>\n\n\n\n
      • \"Q_2\" \u2013 50th percentile (median)<\/li>\n\n\n\n
      • \"Q_3\" \u2013 75th percentile (third quartile)<\/li>\n<\/ul>\n\n
        The interquartile range is defined as \"\text{IQR} = Q_3 - Q_1\" and represents the spread of the central half of the data. It is not very sensitive to outliers because it is based only on the values between the 25th and 75th percentiles of the distribution.  <\/p>\n\n
        A classic use of the IQR is outlier detection using Tukey\u2019s method (values less than \"Q_1 - 1.5 \, \text{IQR}\" or greater than \"Q_3 + 1.5 \, \text{IQR})\".<\/p>\n\n
        <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
        \/**<\/span><\/span>\n * Returns an array with the first, second (median) and third quartile.<\/span><\/span>\n *<\/span><\/span>\n * Method: \"Tukey hinges\".<\/span><\/span>\n *  - Sort the dataset.<\/span><\/span>\n *  - For Q1 and Q3, exclude the median when the sample size is odd.<\/span><\/span>\n *<\/span><\/span>\n * <\/span>@return<\/span> <\/span>float[]<\/span> [Q1, Q2, Q3] in ascending order.<\/span><\/span>\n *\/<\/span><\/span>\n <\/span>public<\/span> <\/span>function<\/span> <\/span>quartiles<\/span>(): <\/span>array<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>$sorted<\/span> = <\/span>$this<\/span>-><\/span>data<\/span>;<\/span><\/span>\n        <\/span>sort<\/span>(<\/span>$sorted<\/span>, SORT_NUMERIC);<\/span><\/span>\n\n        <\/span>$n<\/span> = <\/span>count<\/span>(<\/span>$sorted<\/span>);<\/span><\/span>\n        <\/span>if<\/span> (<\/span>$n<\/span> === <\/span>1<\/span>) {<\/span><\/span>\n            <\/span>return<\/span> [<\/span>$sorted<\/span>[<\/span>0<\/span>], <\/span>$sorted<\/span>[<\/span>0<\/span>], <\/span>$sorted<\/span>[<\/span>0<\/span>]];<\/span><\/span>\n        }<\/span><\/span>\n        <\/span>$mid<\/span> = <\/span>intdiv<\/span>(<\/span>$n<\/span>, <\/span>2<\/span>);<\/span><\/span>\n\n        <\/span>\/\/ Median (Q2)<\/span><\/span>\n        <\/span>$q2<\/span> = (<\/span>$n<\/span> % <\/span>2<\/span> === <\/span>0<\/span>)<\/span><\/span>\n            ? (<\/span>$sorted<\/span>[<\/span>$mid<\/span> - <\/span>1<\/span>] + <\/span>$sorted<\/span>[<\/span>$mid<\/span>]) \/ <\/span>2.0<\/span><\/span>\n            : (<\/span>float<\/span>) <\/span>$sorted<\/span>[<\/span>$mid<\/span>];<\/span><\/span>\n\n        <\/span>\/\/ Lower half (exclude median if n is odd)<\/span><\/span>\n        <\/span>$lower<\/span> = <\/span>array_slice<\/span>(<\/span>$sorted<\/span>, <\/span>0<\/span>, <\/span>$mid<\/span>);<\/span><\/span>\n        <\/span>\/\/ Upper half (exclude median if n is odd)<\/span><\/span>\n        <\/span>$upper<\/span> = <\/span>array_slice<\/span>(<\/span>$sorted<\/span>, (<\/span>$n<\/span> % <\/span>2<\/span> === <\/span>0<\/span>) ? <\/span>$mid<\/span> : <\/span>$mid<\/span> + <\/span>1<\/span>);<\/span><\/span>\n\n        <\/span>\/\/ Q1 and Q3 are medians of the two halves<\/span><\/span>\n        <\/span>$q1<\/span> = <\/span>$this<\/span>-><\/span>medianOfArray<\/span>(<\/span>$lower<\/span>);<\/span><\/span>\n        <\/span>$q3<\/span> = <\/span>$this<\/span>-><\/span>medianOfArray<\/span>(<\/span>$upper<\/span>);<\/span><\/span>\n\n        <\/span>return<\/span> [<\/span>$q1<\/span>, <\/span>$q2<\/span>, <\/span>$q3<\/span>];<\/span><\/span>\n    }<\/span><\/span>\n\n\/**<\/span><\/span>\n * Calculates the interquartile range (Q3 \u2013 Q1).<\/span><\/span>\n *<\/span><\/span>\n * <\/span>@return<\/span> <\/span>float<\/span> The interquartile range.<\/span><\/span>\n *\/<\/span><\/span>\npublic<\/span> <\/span>function<\/span> <\/span>iqr<\/span>(): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    [<\/span>$q1<\/span>, , <\/span>$q3<\/span>] = <\/span>$this<\/span>-><\/span>quartiles<\/span>();<\/span><\/span>\n    <\/span>return<\/span> <\/span>$q3<\/span> - <\/span>$q1<\/span>;<\/span><\/span>\n}<\/span><\/span>\n\n\/* ---------- Helper ---------- *\/<\/span><\/span>\n\/**<\/span><\/span>\n * Median of a pre-sorted array (helper for quartiles).<\/span><\/span>\n *<\/span><\/span>\n * <\/span>@param<\/span> <\/span>float[]<\/span> $arr Sorted numeric array.<\/span><\/span>\n * <\/span>@return<\/span> <\/span>float<\/span> Median value.<\/span><\/span>\n *\/<\/span><\/span>\nprivate<\/span> <\/span>function<\/span> <\/span>medianOfArray<\/span>(<\/span>array<\/span> <\/span>$arr<\/span>): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>$count<\/span> = <\/span>count<\/span>(<\/span>$arr<\/span>);<\/span><\/span>\n    <\/span>if<\/span> (<\/span>$count<\/span> === <\/span>0<\/span>) {<\/span><\/span>\n        <\/span>throw<\/span> <\/span>new<\/span> <\/span>\\LogicException<\/span>(<\/span>'Cannot compute median of an empty array.'<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>$mid<\/span> = <\/span>intdiv<\/span>(<\/span>$count<\/span>, <\/span>2<\/span>);<\/span><\/span>\n\n    <\/span>return<\/span> (<\/span>$count<\/span> % <\/span>2<\/span> === <\/span>0<\/span>)<\/span><\/span>\n        ? (<\/span>$arr<\/span>[<\/span>$mid<\/span> - <\/span>1<\/span>] + <\/span>$arr<\/span>[<\/span>$mid<\/span>]) \/ <\/span>2.0<\/span><\/span>\n        : (<\/span>float<\/span>) <\/span>$arr<\/span>[<\/span>$mid<\/span>];<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n
        When the quartiles()<\/code> method is called, the first thing it does is create a copy of the internal data and sort it in ascending order; this copy preserves the original order provided by the user and allows working with a monotonically ordered vector, which is a necessary prerequisite for identifying quartiles. Immediately afterward, the variable $n<\/code> stores the sample size, and $mid<\/code> represents the central index calculated via integer division. With these two pieces of information, the median of the entire sample is determined, which becomes the second quartile \"Q_2\"; if the number of observations is even, the median is the arithmetic mean of the two central values, whereas in the odd case, it coincides with the value at the central position.  <\/p>\n\n
        Once \"Q_2\" is known, the sorted array is split into two halves. If the sample size is odd, the median must not be included in either the lower or upper part, so the function array_slice<\/code> explicitly excludes it; if it is even, the division occurs exactly in half. At this point, the outer quartiles come into play: to calculate \"Q_1\" and \"Q_3\", no new object is created\u2014rather, the private helper medianOfArray<\/code> is invoked on the two already sorted halves. This small routine receives a vector, counts its elements, determines the central index, and returns the median using the same logic as before; all of this remains confined within the class, keeping the public interface clean and avoiding any code duplication.   <\/p>\n\n
        The quartiles()<\/code> method finally returns an array with the three values \"[Q_1, Q_2, Q_3]\" in ascending order. Its counterpart, iqr()<\/code>, simply unpacks that array, subtracts \"Q_1\" from \"Q_3\", and returns the interquartile range, providing in a single call the most robust measure of dispersion in the class. <\/p>\n\n
        In this setup, the logic for computing the median remains centralized within the private helper, and is reused both for quartiles and, implicitly, for any other internal functionality that might need to calculate a median on a sorted subset. Meanwhile, the public API continues to offer self-explanatory and easy-to-understand methods for anyone integrating your library.<\/p>\n\n
        Variance<\/h2>\n\n
        To measure how much the values deviate from their central tendency, variance<\/strong> is introduced, which calculates the mean of the squared deviations from the arithmetic mean. Given \"n\" observations \"x_1, x_2, \dots, x_n \"with mean \"\bar{x}\", the population variance<\/strong> is defined as: <\/p>\n\n
        \"\sigma^{2} \;=\; \frac{1}{n}\sum_{i=1}^{n}(x_i - \bar{x})^{2}\"<\/p>\n\n
        If instead the data represent a sample<\/strong> drawn from a larger population, the correct estimator (sample variance) divides by \"n − 1\":<\/p>\n\n
        \"s^{2} \;=\; \frac{1}{n-1}\sum_{i=1}^{n}(x_i - \bar{x})^{2}\"<\/p>\n\n
        Variance returns a quadratic<\/strong> value: it is always non-negative and increases rapidly as deviations grow. For this reason, it is often used in conjunction with its square root (standard deviation) to return to the same units of measurement as the data.<\/p>\n\n
        <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
        \/**<\/span><\/span>\n * Calculates the variance of the dataset.<\/span><\/span>\n *<\/span><\/span>\n * <\/span>@param<\/span> <\/span>bool<\/span> $sample If true, uses (n-1) in the denominator (sample variance).<\/span><\/span>\n *                     If false, uses n (population variance).<\/span><\/span>\n * <\/span>@return<\/span> <\/span>float<\/span> The variance value.<\/span><\/span>\n *\/<\/span><\/span>\npublic<\/span> <\/span>function<\/span> <\/span>variance<\/span>(<\/span>bool<\/span> <\/span>$sample<\/span> = <\/span>false<\/span>): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>$n<\/span> = <\/span>count<\/span>(<\/span>$this<\/span>-><\/span>data<\/span>);<\/span><\/span>\n\n    <\/span>\/\/ For a single value, population variance is 0, sample variance is undefined<\/span><\/span>\n    <\/span>if<\/span> (<\/span>$n<\/span> < <\/span>2<\/span> && <\/span>$sample<\/span>) {<\/span><\/span>\n        <\/span>throw<\/span> <\/span>new<\/span> <\/span>\\DomainException<\/span>(<\/span>'Sample variance requires at least two observations.'<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n    <\/span>if<\/span> (<\/span>$n<\/span> === <\/span>1<\/span>) {<\/span><\/span>\n        <\/span>return<\/span> <\/span>0.0<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>$mean<\/span> = <\/span>$this<\/span>-><\/span>mean<\/span>();<\/span><\/span>\n    <\/span>$sumSquares<\/span> = <\/span>0.0<\/span>;<\/span><\/span>\n\n    <\/span>foreach<\/span> (<\/span>$this<\/span>-><\/span>data<\/span> as <\/span>$v<\/span>) {<\/span><\/span>\n        <\/span>$diff<\/span>        = <\/span>$v<\/span> - <\/span>$mean<\/span>;<\/span><\/span>\n        <\/span>$sumSquares<\/span> += <\/span>$diff<\/span> * <\/span>$diff<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>$denominator<\/span> = <\/span>$sample<\/span> ? (<\/span>$n<\/span> - <\/span>1<\/span>) : <\/span>$n<\/span>;<\/span><\/span>\n    <\/span>return<\/span> <\/span>$sumSquares<\/span> \/ <\/span>$denominator<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n
        The method receives a flag indicating whether to calculate the population variance or the sample estimator. It begins by evaluating the dataset size: with only one value, the population variance is by definition zero, whereas the sample variance does not exist and an exception is thrown. Once the mean is known, the loop traverses each observation, subtracts the mean, squares the deviation, and accumulates it. After the summation is complete, the division is performed by \"n\" or \"n − 1\" depending on the specified context, thus returning the desired measure of dispersion.   <\/p>\n\n
        Standard deviation<\/h2>\n\n
        The standard deviation<\/strong> is simply the square root of the variance: it serves to bring the measure of dispersion back to the same units as the original data. If variance indicates \u201chow many squared units\u201d the observations deviate on average from their mean, the standard deviation expresses that deviation in linear units, making it much more intuitive for a non-specialist reader. For the population, it is obtained as \"\sigma = \sqrt{\sigma^{2}}\" while in the sample case it is \"s = \sqrt{s^{2}}\". Small standard deviation values indicate a distribution concentrated around the mean; large values indicate widely dispersed data.   <\/p>\n\n
        <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
        \/**<\/span><\/span>\n * Calculates the standard deviation of the dataset.<\/span><\/span>\n *<\/span><\/span>\n * <\/span>@param<\/span> <\/span>bool<\/span> $sample If true, returns the sample standard deviation (n-1 in the denominator).<\/span><\/span>\n *                     If false, returns the population standard deviation.<\/span><\/span>\n * <\/span>@return<\/span> <\/span>float<\/span> The standard deviation.<\/span><\/span>\n *\/<\/span><\/span>\npublic<\/span> <\/span>function<\/span> <\/span>standardDeviation<\/span>(<\/span>bool<\/span> <\/span>$sample<\/span> = <\/span>false<\/span>): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>return<\/span> <\/span>sqrt<\/span>(<\/span>$this<\/span>-><\/span>variance<\/span>(<\/span>$sample<\/span>));<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n
        The method contains no additional logic: it simply calls variance()<\/code> with the same flag and returns its square root, delegating all calculation and domain checks to the already tested algorithm.<\/p>\n\n
        Standard error of the mean<\/h2>\n\n
        When we observe only a sample from the population, the sample mean is an estimate subject to fluctuations: the smaller the sample, the more the estimate may vary from one sample to another. The standard error of the mean<\/strong> (SEM<\/em>) precisely quantifies this expected variability. If s is the sample standard deviation and n is the sample size, the standard error is calculated as  <\/p>\n\n
        \"\text{SEM} \;=\; \frac{s}{\sqrt{n}}\".<\/p>\n\n
        A small SEM indicates that the mean calculated from that sample is likely close to the true population mean; a large SEM suggests greater uncertainty. The SEM is also the basis for constructing confidence intervals for the mean. <\/p>\n\n
        <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
        \/**<\/span><\/span>\n * Calculates the standard error of the mean (SEM) of the dataset.<\/span><\/span>\n *<\/span><\/span>\n * SEM = sample standard deviation \/ sqrt(n)<\/span><\/span>\n * Requires at least two observations.<\/span><\/span>\n *<\/span><\/span>\n * <\/span>@throws<\/span> <\/span>\\DomainException<\/span> If the dataset size is less than 2.<\/span><\/span>\n * <\/span>@return<\/span> <\/span>float<\/span> The standard error of the mean.<\/span><\/span>\n *\/<\/span><\/span>\npublic<\/span> <\/span>function<\/span> <\/span>standardError<\/span>(): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>$n<\/span> = <\/span>count<\/span>(<\/span>$this<\/span>-><\/span>data<\/span>);<\/span><\/span>\n\n    <\/span>if<\/span> (<\/span>$n<\/span> < <\/span>2<\/span>) {<\/span><\/span>\n        <\/span>throw<\/span> <\/span>new<\/span> <\/span>\\DomainException<\/span>(<\/span>'Standard error requires at least two observations.'<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>return<\/span> <\/span>$this<\/span>-><\/span>standardDeviation<\/span>(<\/span>true<\/span>) \/ <\/span>sqrt<\/span>(<\/span>$n<\/span>);<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n
        The method first retrieves the sample size; if there is only one value, it makes no sense to speak of standard error, so a domain exception is raised. In all other cases, it calls the already implemented sample standard deviation method to obtain \"s\". By dividing \"s\" by the square root of n, it computes the SEM according to the canonical statistical definition and returns the result as a floating-point value. In this way, all numerical logic remains consistent with the other measures of dispersion: the function relies on well-tested methods, does not replicate existing calculations, and guarantees a very simple usage contract.   <\/p>\n\n
        Mean absolute deviation (MAD)<\/h2>\n\n
        To measure dispersion in an intuitive way, without amplifying deviations by squaring them as variance does, the mean absolute deviation<\/strong> (MAD) is used. The idea is simple: calculate the absolute distance between each observation and the arithmetic mean, then take the average of those distances. If the sample consists of the values \"x_1, x_2, \dots, x_n\" and their mean is \"\bar{x}\", the mean absolute deviation is given by:  <\/p>\n\n
        \"\text{MAD} \;=\; \frac{1}{n}\sum_{i=1}^{n} \lvert x_i - \bar{x} \rvert\".<\/p>\n\n
        The mean absolute deviation maintains the same units of measurement as the data, is less sensitive to outliers than the standard deviation, and offers an immediate interpretation: it indicates by how many units, on average, each value deviates from the center of the distribution.<\/p>\n\n
        <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
        \/**<\/span><\/span>\n * Calculates the mean absolute deviation (MAD) of the dataset.<\/span><\/span>\n *<\/span><\/span>\n * <\/span>@return<\/span> <\/span>float<\/span> The mean absolute deviation.<\/span><\/span>\n *\/<\/span><\/span>\npublic<\/span> <\/span>function<\/span> <\/span>meanAbsoluteDeviation<\/span>(): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>$mean<\/span> = <\/span>$this<\/span>-><\/span>mean<\/span>();<\/span><\/span>\n    <\/span>$sumAbs<\/span> = <\/span>0.0<\/span>;<\/span><\/span>\n\n    <\/span>foreach<\/span> (<\/span>$this<\/span>-><\/span>data<\/span> as <\/span>$v<\/span>) {<\/span><\/span>\n        <\/span>$sumAbs<\/span> += <\/span>abs<\/span>(<\/span>$v<\/span> - <\/span>$mean<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>return<\/span> <\/span>$sumAbs<\/span> \/ <\/span>count<\/span>(<\/span>$this<\/span>-><\/span>data<\/span>);<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n
        The method first retrieves the arithmetic mean of the sample using the already existing mean()<\/code> function. With this information, it iterates over each observation, subtracts the mean, takes the absolute value of the deviation, and accumulates it in $sumAbs<\/code>. Once the loop is complete, it divides the sum of absolute deviations by the sample size, returning the result as a floating-point number. The logic remains linear and without conditional branches because the MAD formula does not require distinctions between population and sample: division by \"n\" always applies.   <\/p>\n\n
        Percentiles<\/h2>\n\n
        To locate any given value along the distribution, percentiles<\/strong> are used: the \"pth\" percentile identifies the point below which exactly \"p %\" of the ordered data fall. The 50th percentile coincides with the median, the 25th and 75th form the quartiles already implemented, and in general, knowing multiple percentiles allows for a very detailed description of the distribution\u2019s shape. Since the sample is finite, the percentile position rarely corresponds to an exact integer index: interpolation between adjacent elements is therefore required. A widely adopted convention (Excel and NumPy \u201clinear\u201d method) consists in calculating:   <\/p>\n\n
        \"r = \frac{p}{100}\,(n-1)\"<\/p>\n\n
        where \"n\" is the sample size: if r falls between indices \"k\" and \"k+1\", the percentile is the linear combination of the two values, weighted by the fractional part of \"r\".<\/p>\n\n
        <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
        \/**<\/span><\/span>\n * Returns the p-th percentile of the dataset (linear interpolation).<\/span><\/span>\n *<\/span><\/span>\n * <\/span>@param<\/span> <\/span>float<\/span> $p Percentile in the closed range [0, 100].<\/span><\/span>\n * <\/span>@throws<\/span> <\/span>\\DomainException<\/span> If $p is outside 0\u2013100.<\/span><\/span>\n * <\/span>@return<\/span> <\/span>float<\/span> The requested percentile.<\/span><\/span>\n *\/<\/span><\/span>\npublic<\/span> <\/span>function<\/span> <\/span>percentile<\/span>(<\/span>float<\/span> <\/span>$p<\/span>): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>if<\/span> (<\/span>$p<\/span> < <\/span>0.0<\/span> || <\/span>$p<\/span> > <\/span>100.0<\/span>) {<\/span><\/span>\n        <\/span>throw<\/span> <\/span>new<\/span> <\/span>\\DomainException<\/span>(<\/span>'Percentile must be between 0 and 100.'<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>$sorted<\/span> = <\/span>$this<\/span>-><\/span>data<\/span>;<\/span><\/span>\n    <\/span>sort<\/span>(<\/span>$sorted<\/span>, SORT_NUMERIC);<\/span><\/span>\n    <\/span>$n<\/span> = <\/span>count<\/span>(<\/span>$sorted<\/span>);<\/span><\/span>\n\n    <\/span>\/\/ Edge cases: 0th and 100th percentile<\/span><\/span>\n    <\/span>if<\/span> (<\/span>$p<\/span> === <\/span>0.0<\/span>)   { <\/span>return<\/span> (<\/span>float<\/span>) <\/span>$sorted<\/span>[<\/span>0<\/span>]; }<\/span><\/span>\n    <\/span>if<\/span> (<\/span>$p<\/span> === <\/span>100.0<\/span>) { <\/span>return<\/span> (<\/span>float<\/span>) <\/span>$sorted<\/span>[<\/span>$n<\/span> - <\/span>1<\/span>]; }<\/span><\/span>\n\n    <\/span>\/\/ Linear-interpolated rank<\/span><\/span>\n    <\/span>$rank<\/span>        = (<\/span>$p<\/span> \/ <\/span>100.0<\/span>) * (<\/span>$n<\/span> - <\/span>1<\/span>);<\/span><\/span>\n    <\/span>$lowerIndex<\/span>  = (<\/span>int<\/span>) <\/span>floor<\/span>(<\/span>$rank<\/span>);<\/span><\/span>\n    <\/span>$upperIndex<\/span>  = (<\/span>int<\/span>) <\/span>ceil<\/span>(<\/span>$rank<\/span>);<\/span><\/span>\n    <\/span>$weightUpper<\/span> = <\/span>$rank<\/span> - <\/span>$lowerIndex<\/span>;<\/span><\/span>\n\n    <\/span>\/\/ If rank is an integer, no interpolation is needed<\/span><\/span>\n    <\/span>if<\/span> (<\/span>$lowerIndex<\/span> === <\/span>$upperIndex<\/span>) {<\/span><\/span>\n        <\/span>return<\/span> (<\/span>float<\/span>) <\/span>$sorted<\/span>[<\/span>$lowerIndex<\/span>];<\/span><\/span>\n    }<\/span><\/span>\n\n    <\/span>$lowerValue<\/span> = <\/span>$sorted<\/span>[<\/span>$lowerIndex<\/span>];<\/span><\/span>\n    <\/span>$upperValue<\/span> = <\/span>$sorted<\/span>[<\/span>$upperIndex<\/span>];<\/span><\/span>\n\n    <\/span>return<\/span> (<\/span>1.0<\/span> - <\/span>$weightUpper<\/span>) * <\/span>$lowerValue<\/span> + <\/span>$weightUpper<\/span> * <\/span>$upperValue<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n
        The method first validates that the requested percentile lies between 0 and 100 inclusive, thus ensuring consistency with the statistical definition. It then creates a sorted copy of the data, since any percentile localization requires a monotonically increasing vector. The boundary cases 0 and 100 are handled explicitly by returning the minimum and maximum of the sample, respectively. For all other values, the real rank \"r\" is calculated, which may fall between two integer indices; the lower and upper indices define the interval containing the fractional position. If \"r\" is already an integer, no interpolation is needed and the method returns the corresponding element directly. Otherwise, the lower and upper values are linearly combined using a weight equal to the decimal part of \"r\", yielding a continuous result that flows smoothly between the elements of the sample.     <\/p>\n\n
        Minimum and Maximum<\/h2>\n\n
        To complete the overview of descriptive measures, it is useful to be able to quickly retrieve the lower and upper extremes of the distribution. The minimum value<\/strong> indicates the smallest observation recorded in the sample; the maximum <\/strong>marks the largest. These two quantities, although extremely simple, are essential both for providing context to the data (knowing where the observed interval begins and ends) and as components of other statistics, such as the range you have already implemented. Since the dataset is entirely in memory, finding the minimum and maximum requires only a single linear scan, and the computational cost is negligible.   <\/p>\n\n
        <\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
        \/**<\/span><\/span>\n * Returns the minimum value of the dataset.<\/span><\/span>\n *<\/span><\/span>\n * <\/span>@return<\/span> <\/span>float<\/span> The smallest observation.<\/span><\/span>\n *\/<\/span><\/span>\npublic<\/span> <\/span>function<\/span> <\/span>minValue<\/span>(): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>return<\/span> (<\/span>float<\/span>) <\/span>min<\/span>(<\/span>$this<\/span>-><\/span>data<\/span>);<\/span><\/span>\n}<\/span><\/span>\n\n\/**<\/span><\/span>\n * Returns the maximum value of the dataset.<\/span><\/span>\n *<\/span><\/span>\n * <\/span>@return<\/span> <\/span>float<\/span> The largest observation.<\/span><\/span>\n *\/<\/span><\/span>\npublic<\/span> <\/span>function<\/span> <\/span>maxValue<\/span>(): <\/span>float<\/span><\/span>\n{<\/span><\/span>\n    <\/span>return<\/span> (<\/span>float<\/span>) <\/span>max<\/span>(<\/span>$this<\/span>-><\/span>data<\/span>);<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n
        The PHP functions min() and max() scan the array only once; the cast ensures that the returned type is float, consistent with the rest of the API.<\/p>\n\n
        Conclusions<\/h2>\n\n
        With this final method, we have completed our DescriptiveStats<\/code> class, which now encapsulates in a single component the most important tools of descriptive statistics: from measures of central tendency (arithmetic mean, median, mode, percentiles) to measures of dispersion (range, variance, standard deviation, IQR, MAD), including indicators of robustness (trimmed mean) and uncertainty (standard error).Each function is self-contained, strongly typed, and supported by automated PHPUnit tests, which we have not included here so as not to further lengthen an article already rich in content.  <\/p>\n\n
        Thanks to this library, a PHP project can quickly analyze small datasets without external dependencies and without having to use artificial intelligence just to compute a \u201cmode\u201d, integrate statistical calculations into reports, dashboards, or APIs, and extend the class with additional indicators by leveraging a clear and consistent architecture. <\/p>\n\n
        In the next article, we will see how to transform the code into a Composer package: we will create the final structure of the repository, review how to modify the composer.json<\/code> file, configure CI to run the tests, and publish the library on Packagist, making it installable with a simple:<\/p>\n\n
        composer require thesimon82\/descriptive-statistics<\/code><\/p>\n\n
        In this way, you will be able to distribute your open-source solution, receive contributions from the community, and reuse it in any project with maximum simplicity.<\/p>\n\n
        [starbox]<\/p>\n","protected":false},"excerpt":{"rendered":"
        In the world of software development, data analysis is becoming increasingly central. With the advent of artificial intelligence in the consumer market, many now use it to analyze statistical data as well. However, in many cases, the use of this technology is not required and is actually less efficient than a solid algorithm designed to […]<\/p>\n","protected":false},"author":2,"featured_media":486,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"_writerflow_disable_suggestions":false,"footnotes":""},"categories":[1977],"tags":[1406,1407,1397,1408,1409,1410,1411,1412,1413,1400,1414,1391,1415,1416,1417,1418,1419,1420],"class_list":["post-668","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-sviluppo-software-programmazione","tag-applied-mathematics","tag-arithmetic-mean","tag-composer-en","tag-data-analysis","tag-descriptive-statistics","tag-iqr-en","tag-mean-absolute-deviation","tag-median","tag-mode","tag-packagist-en","tag-percentiles","tag-php-en","tag-php-library-en-2","tag-php-tutorial","tag-programming","tag-standard-deviation","tag-standard-error","tag-variance"],"acf":[],"yoast_head":"\nA Descriptive Statistics Class in PHP | RENOR & Partners S.r.l.<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"A Descriptive Statistics Class in PHP\" \/>\n<meta property=\"og:description\" content=\"In the world of software development, data analysis is becoming increasingly central. With the advent of artificial intelligence in the consumer market, many now use it to analyze statistical data as well. However, in many cases, the use of this technology is not required and is actually less efficient than a solid algorithm designed to […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/\" \/>\n<meta property=\"og:site_name\" content=\"RENOR & Partners S.r.l.\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/renorsrl\" \/>\n<meta property=\"article:author\" content=\"https:\/\/www.facebook.com\/simone.renzi.3954\/\" \/>\n<meta property=\"article:published_time\" content=\"2025-05-12T19:06:41+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-12-20T14:53:57+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/statistica-descrittiva.webp\" \/>\n\t<meta property=\"og:image:width\" content=\"1536\" \/>\n\t<meta property=\"og:image:height\" content=\"1024\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/webp\" \/>\n<meta name=\"author\" content=\"Simone Renzi\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Simone Renzi\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"28 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/a-descriptive-statistics-class-in-php\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/a-descriptive-statistics-class-in-php\\\/\"},\"author\":{\"name\":\"Simone Renzi\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#\\\/schema\\\/person\\\/21343be04e5983a87f3a9a6182cf8795\"},\"headline\":\"A Descriptive Statistics Class in PHP\",\"datePublished\":\"2025-05-12T19:06:41+00:00\",\"dateModified\":\"2025-12-20T14:53:57+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/a-descriptive-statistics-class-in-php\\\/\"},\"wordCount\":4203,\"publisher\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/a-descriptive-statistics-class-in-php\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/05\\\/statistica-descrittiva.webp\",\"keywords\":[\"applied mathematics\",\"arithmetic mean\",\"Composer\",\"data analysis\",\"descriptive statistics\",\"IQR\",\"mean absolute deviation\",\"median\",\"mode\",\"Packagist\",\"percentiles\",\"php\",\"PHP library\",\"PHP tutorial\",\"programming\",\"standard deviation\",\"standard error\",\"variance\"],\"articleSection\":[\"Sviluppo Software & Programmazione\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/a-descriptive-statistics-class-in-php\\\/\",\"url\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/a-descriptive-statistics-class-in-php\\\/\",\"name\":\"A Descriptive Statistics Class in PHP | RENOR & Partners S.r.l.\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/a-descriptive-statistics-class-in-php\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/a-descriptive-statistics-class-in-php\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/05\\\/statistica-descrittiva.webp\",\"datePublished\":\"2025-05-12T19:06:41+00:00\",\"dateModified\":\"2025-12-20T14:53:57+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/a-descriptive-statistics-class-in-php\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/a-descriptive-statistics-class-in-php\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/a-descriptive-statistics-class-in-php\\\/#primaryimage\",\"url\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/05\\\/statistica-descrittiva.webp\",\"contentUrl\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/05\\\/statistica-descrittiva.webp\",\"width\":1536,\"height\":1024,\"caption\":\"Figura 1 \u2013 Lavagna che riassume le principali formule di statistica descrittiva implementate nella classe DescriptiveStats (\u03bc, x\u0304\u2098\u2091d, \u03c3\u00b2, IQR, SEM, MAD) scritte a mano in stile gesso.\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/sviluppo-software-programmazione\\\/a-descriptive-statistics-class-in-php\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/renor.it\\\/en\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Blog\",\"item\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Software Development & Programming\",\"item\":\"https:\\\/\\\/renor.it\\\/en\\\/blog\\\/software-development-programming\\\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"A Descriptive Statistics Class in PHP\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#website\",\"url\":\"https:\\\/\\\/renor.it\\\/en\\\/\",\"name\":\"RENOR & Partners S.r.l.\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#organization\"},\"alternateName\":\"RENOR & Partners S.r.l.\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/renor.it\\\/en\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#organization\",\"name\":\"RENOR & Partners S.r.l.\",\"url\":\"https:\\\/\\\/renor.it\\\/en\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/12\\\/logo-new-1.webp\",\"contentUrl\":\"https:\\\/\\\/renor.it\\\/wp-content\\\/uploads\\\/2025\\\/12\\\/logo-new-1.webp\",\"width\":432,\"height\":146,\"caption\":\"RENOR & Partners S.r.l.\"},\"image\":{\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/renorsrl\",\"https:\\\/\\\/www.instagram.com\\\/renorpartners\\\/\",\"https:\\\/\\\/www.linkedin.com\\\/company\\\/renor-partners\\\/posts\\\/?feedView=all\"],\"description\":\"RENOR & Partners Srl \u00e8 una societ\u00e0 di consulenza tecnologica e ingegneristica specializzata in sviluppo software, cloud computing, integrazione di sistemi, intelligenza artificiale applicata e progettazione elettronica. L\u2019azienda supporta imprese e pubbliche amministrazioni nella realizzazione di soluzioni digitali affidabili, scalabili e orientate all\u2019efficienza, con un approccio pragmatico basato su competenze tecniche, progettazione su misura e innovazione concreta.\",\"email\":\"info@renor.it\",\"telephone\":\"3791489430\",\"legalName\":\"RENOR AND PARTNERS S.r.l.\",\"foundingDate\":\"2022-06-21\",\"vatID\":\"16768411007\",\"taxID\":\"16768411007\",\"numberOfEmployees\":{\"@type\":\"QuantitativeValue\",\"minValue\":\"1\",\"maxValue\":\"10\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/renor.it\\\/en\\\/#\\\/schema\\\/person\\\/21343be04e5983a87f3a9a6182cf8795\",\"name\":\"Simone Renzi\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g\",\"caption\":\"Simone Renzi\"},\"description\":\"Senior full-stack web engineer with over 20 years of experience in cloud architectures, AI, and SaaS solutions; member of Mensa Italia. Creator of platforms such as HR24.ai and Paghe.ai, he oversaw the web development of FNS, a neural network simulator cited in Scientific Reports (Nature Portfolio), and has collaborated on research projects with INFN \u2013 Laboratori Nazionali di Frascati, Universit\u00e0 di Roma \u201cTor Vergata\u201d, Universidad Complutense, Universidad Polit\u00e9cnica and Centro de Tecnolog\u00eda Biom\u00e9dica in Madrid. A classical pianist, he combines musical creativity and technological rigor in every project.\",\"sameAs\":[\"https:\\\/\\\/renor.it\",\"https:\\\/\\\/www.facebook.com\\\/simone.renzi.3954\\\/\",\"https:\\\/\\\/www.linkedin.com\\\/in\\\/simone-renzi\"],\"url\":\"https:\\\/\\\/renor.it\\\/en\\\/author\\\/thesimon\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"A Descriptive Statistics Class in PHP | RENOR & Partners S.r.l.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/","og_locale":"en_US","og_type":"article","og_title":"A Descriptive Statistics Class in PHP","og_description":"In the world of software development, data analysis is becoming increasingly central. With the advent of artificial intelligence in the consumer market, many now use it to analyze statistical data as well. However, in many cases, the use of this technology is not required and is actually less efficient than a solid algorithm designed to […]","og_url":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/","og_site_name":"RENOR & Partners S.r.l.","article_publisher":"https:\/\/www.facebook.com\/renorsrl","article_author":"https:\/\/www.facebook.com\/simone.renzi.3954\/","article_published_time":"2025-05-12T19:06:41+00:00","article_modified_time":"2025-12-20T14:53:57+00:00","og_image":[{"width":1536,"height":1024,"url":"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/statistica-descrittiva.webp","type":"image\/webp"}],"author":"Simone Renzi","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Simone Renzi","Est. reading time":"28 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/#article","isPartOf":{"@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/"},"author":{"name":"Simone Renzi","@id":"https:\/\/renor.it\/en\/#\/schema\/person\/21343be04e5983a87f3a9a6182cf8795"},"headline":"A Descriptive Statistics Class in PHP","datePublished":"2025-05-12T19:06:41+00:00","dateModified":"2025-12-20T14:53:57+00:00","mainEntityOfPage":{"@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/"},"wordCount":4203,"publisher":{"@id":"https:\/\/renor.it\/en\/#organization"},"image":{"@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/#primaryimage"},"thumbnailUrl":"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/statistica-descrittiva.webp","keywords":["applied mathematics","arithmetic mean","Composer","data analysis","descriptive statistics","IQR","mean absolute deviation","median","mode","Packagist","percentiles","php","PHP library","PHP tutorial","programming","standard deviation","standard error","variance"],"articleSection":["Sviluppo Software & Programmazione"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/","url":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/","name":"A Descriptive Statistics Class in PHP | RENOR & Partners S.r.l.","isPartOf":{"@id":"https:\/\/renor.it\/en\/#website"},"primaryImageOfPage":{"@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/#primaryimage"},"image":{"@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/#primaryimage"},"thumbnailUrl":"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/statistica-descrittiva.webp","datePublished":"2025-05-12T19:06:41+00:00","dateModified":"2025-12-20T14:53:57+00:00","breadcrumb":{"@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/#primaryimage","url":"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/statistica-descrittiva.webp","contentUrl":"https:\/\/renor.it\/wp-content\/uploads\/2025\/05\/statistica-descrittiva.webp","width":1536,"height":1024,"caption":"Figura 1 \u2013 Lavagna che riassume le principali formule di statistica descrittiva implementate nella classe DescriptiveStats (\u03bc, x\u0304\u2098\u2091d, \u03c3\u00b2, IQR, SEM, MAD) scritte a mano in stile gesso."},{"@type":"BreadcrumbList","@id":"https:\/\/renor.it\/en\/blog\/sviluppo-software-programmazione\/a-descriptive-statistics-class-in-php\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/renor.it\/en\/"},{"@type":"ListItem","position":2,"name":"Blog","item":"https:\/\/renor.it\/en\/blog\/"},{"@type":"ListItem","position":3,"name":"Software Development & Programming","item":"https:\/\/renor.it\/en\/blog\/software-development-programming\/"},{"@type":"ListItem","position":4,"name":"A Descriptive Statistics Class in PHP"}]},{"@type":"WebSite","@id":"https:\/\/renor.it\/en\/#website","url":"https:\/\/renor.it\/en\/","name":"RENOR & Partners S.r.l.","description":"","publisher":{"@id":"https:\/\/renor.it\/en\/#organization"},"alternateName":"RENOR & Partners S.r.l.","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/renor.it\/en\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/renor.it\/en\/#organization","name":"RENOR & Partners S.r.l.","url":"https:\/\/renor.it\/en\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/renor.it\/en\/#\/schema\/logo\/image\/","url":"https:\/\/renor.it\/wp-content\/uploads\/2025\/12\/logo-new-1.webp","contentUrl":"https:\/\/renor.it\/wp-content\/uploads\/2025\/12\/logo-new-1.webp","width":432,"height":146,"caption":"RENOR & Partners S.r.l."},"image":{"@id":"https:\/\/renor.it\/en\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/renorsrl","https:\/\/www.instagram.com\/renorpartners\/","https:\/\/www.linkedin.com\/company\/renor-partners\/posts\/?feedView=all"],"description":"RENOR & Partners Srl \u00e8 una societ\u00e0 di consulenza tecnologica e ingegneristica specializzata in sviluppo software, cloud computing, integrazione di sistemi, intelligenza artificiale applicata e progettazione elettronica. L\u2019azienda supporta imprese e pubbliche amministrazioni nella realizzazione di soluzioni digitali affidabili, scalabili e orientate all\u2019efficienza, con un approccio pragmatico basato su competenze tecniche, progettazione su misura e innovazione concreta.","email":"info@renor.it","telephone":"3791489430","legalName":"RENOR AND PARTNERS S.r.l.","foundingDate":"2022-06-21","vatID":"16768411007","taxID":"16768411007","numberOfEmployees":{"@type":"QuantitativeValue","minValue":"1","maxValue":"10"}},{"@type":"Person","@id":"https:\/\/renor.it\/en\/#\/schema\/person\/21343be04e5983a87f3a9a6182cf8795","name":"Simone Renzi","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/54f81b51be6bda6d63a06a1cd6563d9b0d5778d7af4f0bda4e246fc3e5737e2e?s=96&d=mm&r=g","caption":"Simone Renzi"},"description":"Senior full-stack web engineer with over 20 years of experience in cloud architectures, AI, and SaaS solutions; member of Mensa Italia. Creator of platforms such as HR24.ai and Paghe.ai, he oversaw the web development of FNS, a neural network simulator cited in Scientific Reports (Nature Portfolio), and has collaborated on research projects with INFN \u2013 Laboratori Nazionali di Frascati, Universit\u00e0 di Roma \u201cTor Vergata\u201d, Universidad Complutense, Universidad Polit\u00e9cnica and Centro de Tecnolog\u00eda Biom\u00e9dica in Madrid. A classical pianist, he combines musical creativity and technological rigor in every project.","sameAs":["https:\/\/renor.it","https:\/\/www.facebook.com\/simone.renzi.3954\/","https:\/\/www.linkedin.com\/in\/simone-renzi"],"url":"https:\/\/renor.it\/en\/author\/thesimon\/"}]}},"_links":{"self":[{"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/posts\/668","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/comments?post=668"}],"version-history":[{"count":0,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/posts\/668\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/media\/486"}],"wp:attachment":[{"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/media?parent=668"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/categories?post=668"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/renor.it\/en\/wp-json\/wp\/v2\/tags?post=668"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}