Fivenum: Difference between revisions

 

;Note:

<br><br>

 

{{trans|Python}}

 

V n = array.len

V x = sorted(array)

1.04312009, -0.10305385, 0.75775634, 0.32566578]

 

 

{{out}}

<pre>

[-1.9506, -0.676741, 0.233247, 0.746071, 1.73132]

</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|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>

[-1.95059594 -0.62759469 0.14082834 0.73438555 1.73131507]

</pre>

=={{header|Haskell}}==

{{trans|Python}}

 

fivenum [] = []

fivenum xs

| l >= 5 =

fmap

[1, q, succ l / 2, succ l - q, l]

| otherwise = s

q = realToFrac (floor $ (l + 3) / 2) / 2

s = sort xs

 

main :: IO ()

{{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}}

[-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;

 

 

 

</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, ]

 

[-1.950594000000000, -0.676741205000000, 0.233247060000000, 0.746070945000000, 1.731315070000000, ]</pre>

 

=={{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*/

bSort: procedure expose @.; parse arg n; m=n-1 /*N: the number of @ array elements.*/

do m=m for m by -1 until ok; ok= 1 /*keep sorting the @ array 'til done.*/

end /*j*/

end /*m*/; return

if \datatype(@.j, 'N') then return er j "isn't numeric: " @.j

LO= min(LO, @.j); HI= max(HI, @.j)

{{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>

[7.0, 15.0, 36.0, 40.0, 41.0]

[-1.95059594, -0.72588772, 0.14082834, 0.75775634, 1.73131507]</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>