Fivenum: Difference between revisions

{{trans|Python}}

 

V n = array.len

V x = sorted(array)

1.04312009, -0.10305385, 0.75775634, 0.32566578]

 

 

{{out}}

 

=={{header|Ada}}==

{{trans|C}}

with Ada.Containers.Generic_Array_Sort;

 

print (Result, 9);

end Main;

{{output}}

<pre>

[-1.950595940, -0.627594690, 0.119158120, 1.599037385, 1.731315070]

</pre>

with Ada.Containers.Generic_Array_Sort;

 

print (Result);

end Main;

{{output}}

<pre>

[ -1.950595940, -0.736050605, 0.119158120, 1.599037385, 1.731315070]

</pre>

 

=={{header|ALGOL 68}}==

{{Trans|11l}}

PROC fivenum = ( []REAL array )[]REAL:

BEGIN

INT n = ( UPB array + 1 ) - LWB array;

[ 1 : n ]REAL x := array[ AT 1 ];

REAL n4 = ( ( ( n + IF ODD n THEN 3 ELSE 2 FI ) / 2 ) / 2 ) ;

[]REAL d = ( 1, n4, ( n + 1 ) / 2, n + 1 - n4, n );

sum_array

END # five num # ;

print( ( newline ) );

print( ( newline ) );

{{out}}

<pre>

=={{header|AppleScript}}==

 

use framework "Foundation"

 

set z to {0.14082834, 0.0974879, 1.73131507, 0.87636009, -1.95059594, 0.73438555, -0.03035726, 1.4667597, -0.74621349, -0.72588772, ¬

0.6390516, 0.61501527, -0.9898378, -1.00447874, -0.62759469, 0.66206163, 1.04312009, -0.10305385, 0.75775634, 0.32566578}

 

{{output}}

 

=={{header|Arturo}}==

 

lst: sort lst

m: (size lst)/2

print [fivenum l]

print ""

 

{{out}}

[0.14082834 0.0974879 1.73131507 0.87636009 -1.95059594 0.7343855500000001 -0.03035726 1.4667597 -0.74621349 -0.72588772 0.6390516000000001 0.61501527 -0.9898378 -1.00447874 -0.62759469 0.66206163 1.04312009 -0.10305385 0.75775634 0.32566578] ->

[-1.95059594 -0.676741205 0.23324706 0.746070945 1.73131507]</pre>

 

=={{header|C}}==

{{trans|Kotlin}}

#include <stdlib.h>

 

 

return 0;

 

{{out}}

=={{header|C sharp|C#}}==

{{trans|Java}}

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre>[6.00000000, 25.50000000, 40.00000000, 42.50000000, 49.00000000]

=={{header|C++}}==

{{trans|D}}

#include <iostream>

#include <ostream>

 

return 0;

{{out}}

<pre>(6, 25.5, 40, 43, 49)

=={{header|D}}==

{{trans|Java}}

import std.exception;

import std.math;

writeln(fivenum(x));

}

{{out}}

<pre>[6, 25.5, 40, 43, 49]

{{libheader| System.Generics.Collections}}

{{Trans|Java}}

program Fivenum;

 

 

readln;

{{out}}

<pre>

[-1,9506,-0,6767,0,2332,0,7461,1,7313]

</pre>

{{trans|C#}}

 

// Take from https://stackoverflow.com/a/1175123

Console.WriteLine("{0}", y);

 

{{out}}

<pre>[(6, 25.5, 40, 42.5, 49)]

 

=={{header|Factor}}==

math.statistics prettyprint sequences sorting ;

IN: rosetta-code.five-number

[ fivenum . ] tri@ ;

 

{{out}}

<pre>

=={{header|Go}}==

{{trans|Perl}}

 

import (

fmt.Println(fivenum(x2))

fmt.Println(fivenum(x3))

{{out}}

<pre>

 

This solution is aimed at handling larger data sets more efficiently. It replaces the O(n log n) sort with O(n) quickselect. It also does not attempt to reproduce the R result exactly, to average values to get a median of an even number of data values, or otherwise estimate quantiles. The quickselect here leaves the input partitioned around the selected value, which allows another small optimization: The first quickselect call partitions the full input around the median. The second call, to get the first quartile, thus only has to process the partition up to the median. The third call, to get the minimum, only has to process the partition up to the first quartile. The 3rd quartile and maximum are obtained similarly.

 

import (

fmt.Println(fivenum(x2))

fmt.Println(fivenum(x3))

{{out}}

<pre>

=={{header|Groovy}}==

{{trans|Java}}

static double median(double[] x, int start, int endInclusive) {

int size = endInclusive - start + 1

}

}

{{out}}

<pre>[6.0, 25.5, 40.0, 42.5, 49.0]

=={{header|Haskell}}==

{{trans|Python}}

 

fivenum :: [Double] -> [Double]

0.75775634,

0.32566578

{{out}}

<pre>[-1.95059594,-0.676741205,0.23324706,0.746070945,1.73131507]</pre>

=={{header|J}}==

'''Solution'''

quartiles=: -:@(+/)@((<. ,: >.)@midpts { /:~@]) NB. quartiles of y

'''Example Usage'''

test2=: 36 40 7 39 41 15

test3=: , 0 ". ];._2 noun define

6 25.5 40 42.5 49

7 15 37.5 40 41

 

=={{header|Java}}==

{{trans|Kotlin}}

 

public class Fivenum {

for (double[] x : xl) System.out.printf("%s\n\n", Arrays.toString(fivenum(x)));

}

 

{{out}}

 

=={{header|JavaScript}}==

function median(arr) {

let mid = Math.floor(arr.length / 2);

0.66206163, 1.04312009, -0.10305385, 0.75775634, 0.32566578];

console.log( test.fiveNums() );

{{out}}<pre>

> Array(5) [ 6, 25.5, 40, 42.5, 49 ]

> Array(5) [ -1.95059594, -0.676741205, 0.23324706, 0.746070945, 1.73131507 ]

</pre>

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

len = l - i + 1

len > zero(len) || throw(ArgumentError("Array slice cannot be empty."))

0.75775634, 0.32566578])

println("# ", v, "\n -> ", fivenum(v))

 

{{out}}

 

As arrays containing NaNs and nulls cannot really be dealt with in a sensible fashion in Kotlin, they've been excluded altogether.

 

fun median(x: DoubleArray, start: Int, endInclusive: Int): Double {

)

xl.forEach { println("${fivenum(it).asList()}\n") }

 

{{out}}

 

=={{header|Lua}}==

local copy = {}

 

for i,x in ipairs(x1) do

print(fivenum(x))

{{out}}

<pre>6 25.5 40 43 49

=={{header|MATLAB}} / {{header|Octave}}==

 

function r = fivenum(x)

r = quantile(x,[0:4]/4);

end;

 

 

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

FiveNum[x_List] := Quantile[x, Range[0, 1, 1/4]]

{{out}}

<pre>{-3.70325, -0.686977, -0.0087185, 0.652979, 3.67416}</pre>

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM LongStr IMPORT RealToStr;

 

ReadChar

{{out}}

<pre>[6.000000000000000, 25.499999999999900, 40.000000000000000, 42.499999999999900, 49.000000000000000, ]

=={{header|Nim}}==

{{trans|Kotlin}}

 

type FiveNum = array[5, float]

echo ""

echo list

 

{{out}}

 

=={{header|Perl}}==

 

sub fivenum {

0.66206163, 1.04312009, -0.10305385, 0.75775634, 0.32566578);

@tukey = fivenum(\@x);

 

{{out}}

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(let N (length Lst)

(if (bit? 1 N)

0.73438555 -0.03035726 1.46675970 -0.74621349 -0.72588772

0.63905160 0.61501527 -0.98983780 -1.00447874 -0.62759469

{{out}}

<pre>

 

'''Work with: Python 3'''

import math

import sys

 

y = fivenum(x)

 

{{out}}

 

(Though these 25% and 75% values do '''not''' correspond to the Fivenum Tukey quartile values specified in this task)

 

{{out}}

 

To get the fivenum values asked for, the [https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.quantile.html pandas.DataFrame.quantile] function can be used:

 

{{out}}

===Python: Functional – without imports===

'''Works with: Python 3'''

def fiveNums(xs):

def median(xs):

print(

fiveNums(xs)

{{Out}}

<pre>(6, 25.5, 40, 42.5, 49)

The '''fivenum''' function is built-in, see [https://stat.ethz.ch/R-manual/R-devel/library/stats/html/fivenum.html R manual].

 

 

 

'''Output'''

Racket's =quantile= functions use a different method to Tukey; so a new implementation was made.

 

(require math/private/statistics/quickselect)

 

-0.98983780 -1.00447874 -0.62759469 0.66206163 1.04312009 -0.10305385

0.75775634 0.32566578))

 

This program passes its tests silently.

(formerly Perl 6)

{{trans|Perl}}

my $end_22 = $end div 2 / 2;

 

0.66206163, 1.04312009, -0.10305385, 0.75775634, 0.32566578,

];

 

{{out}}

=={{header|Relation}}==

Min, median and max are built in, quarter1 and quarter3 calculated.

program fivenum(X)

rename X^ x

insert 8

run fivenum("a")

 

{{out}}

=={{header|REXX}}==

Programming note: &nbsp; this REXX program uses a unity─based array.

parse arg x

if x='' then x= 15 6 42 41 7 36 49 40 39 47 43 /*Not specified? Then use the defaults*/

if #//2 then p25= q2 /*calculate the second quartile number.*/

else p25= q2 - 1 /* " " " " " */

{{out|output|text=&nbsp; when using the default input of: &nbsp; &nbsp; <tt> 15 6 42 41 7 36 49 40 39 47 43 </tt>}}

<pre>

 

=={{header|Ring}}==

rem1 = 0

rem2 = 0

next

? "[" + left(svect, len(svect) - 1) + "]"

{{out}}

<pre>

[7,15,37.5,40,41]

[-1.95059594,-0.67674121,0.23324706,0.74607095,1.73131507]

</pre>

 

=={{header|Ruby}}==

{{trans|Perl}}

sorted_arr = array.sort

n = array.size

tukey_array = fivenum(test_array)

p tukey_array

{{out}}

<pre>

 

=={{header|Rust}}==

#[derive(Debug)]

struct FiveNum {

}

}

{{out}}

<pre>

 

=={{header|SAS}}==

data test;

do i=1 to 10000;

proc means data=test min p25 median p75 max;

var x;

 

'''Output'''

=={{header|Scala}}==

===Array based solution===

 

object Fivenum extends App {

}

 

{{Out}}See it running in your browser by [https://scalafiddle.io/sf/8s0OdOO/2 ScalaFiddle (JavaScript, non JVM)] or by [https://scastie.scala-lang.org/Ady3dSnoRRKNhCaZYIVbig Scastie (JVM)].

 

=={{header|Sidef}}==

{{trans|Raku}}

var t = ((e>>1) / 2)

[0, t, e/2, e - t, e]

]]

 

{{out}}

<pre>6, 25.5, 40, 42.5, 49

First build a dataset:

 

set seed 17760704

qui set obs 10000

 

The '''[https://www.stata.com/help.cgi?summarize summarize]''' command produces all the required statistics, and more:

 

 

'''Output'''

It's also possible to use the '''[https://www.stata.com/help.cgi?tabstat tabstat]''' command

 

 

'''Output'''

Another example:

 

mat a=0.14082834\0.09748790\1.73131507\0.87636009\-1.95059594\ ///

0.73438555\-0.03035726\1.46675970\-0.74621349\-0.72588772\ ///

0.66206163\1.04312009\-0.10305385\0.75775634\0.32566578

svmat a

 

'''Output'''

a1 | -1.950596 -.6767412 .2332471 .746071 1.731315

----------------------------------------------------------------</pre>

 

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-sort}}

 

var fivenum = Fn.new { |a|

0.66206163, 1.04312009, -0.10305385, 0.75775634, 0.32566578

]

 

{{out}}

=={{header|zkl}}==

Uses GNU GSL library.

fcn fiveNum(v){ // V is a GSL Vector, --> min, 1st qu, median, 3rd qu, max

v.sort();

return(v.min(),v.quantile(0.25),v.median(),v.quantile(0.75),v.max())

15.0, 6.0, 42.0, 41.0, 7.0, 36.0, 49.0, 40.0, 39.0, 47.0, 43.0)).println();

println(fiveNum(GSL.VectorFromData(36.0, 40.0, 7.0, 39.0, 41.0, 15.0)));

-0.98983780, -1.00447874, -0.62759469, 0.66206163, 1.04312009, -0.10305385,

0.75775634, 0.32566578);

{{out}}

<pre>