Averages/Mode: Difference between revisions

If it is not appropriate or possible to support a general collection, use a vector (array), if possible. If it is not appropriate or possible to support an unspecified value type, use integers.

 

 

=={{Header|ActionScript}}==

return modeList;

}</lang>

=={{Header|Ada}}==

{{works with|Ada 2005}}

mode.ads:

<lang Ada>generic

 

end Mode;</lang>

mode.adb:

<lang Ada>with Ada.Containers.Indefinite_Vectors;

 

end Mode;</lang>

example use:

<lang Ada>with Ada.Text_IO;

Ada.Text_IO.New_Line;

end Main;</lang>

<pre>Input: 1, 2, 3, 1, 2, 4, 2, 5, 2, 3, 3, 1, 3, 6

Result: 2, 3</pre>

=={{Header|AutoHotkey}}==

{{AutoHotkey case}}

Source: [http://www.autohotkey.com/forum/post-276175.html#276175 AutoHotkey forum] by Laszlo

<lang autohotkey>MsgBox % Mode("1 2 3")

= J%

</lang>

<pre>Mode(s) of a() = 6

Mode(s) of b() = 1 4</pre>

free(vc);

return 0;

value = 6, count = 4

 

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

return 0;

}</lang>

2 3

 

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

using System.Collections;

using System.Collections.Generic;

sorted (sort-by (comp - freq) distrib)

maxfq (freq (first sorted))]

 

== {{header|CoffeeScript}} ==

# returns an array with the modes of arr, i.e. the

# elements that appear most often in arr

(key for key, cnt of counts when cnt == max)

 

== {{header|Common Lisp}} ==

The following returns a list of the modes of a sequence as the primary value, and the frequency as the secondary value. E.g., <code>(mode '(a b c d a b c a b))</code> produces <code>(A B)</code> and <code>3</code>. hash-table-options can be used to customize the hash table, e.g., to specify the test by which elements are compared.

<lang lisp>(defun mode (sequence &rest hash-table-options)

writeln("Mode: ", mode(data));

}</lang>

<pre>Mode: [3]

Mode: [2, 3]</pre>

 

=={{header|E}}==

<lang e>pragma.enable("accumulator")

def mode(values) {

return accum [].asSet() for v => ==maxCount in counts { _.with(v) }

}</lang>

<lang e>? mode([1,1,2,2,3,3,4,4,4,5,5,6,6,7,8,8,9,9,0,0,0])

# value: [4, 0].asSet()</lang>

In the line "<code>maxCount max= (counts[v] := counts.fetch(v, fn{0}) + 1)</code>", <code>max=</code> is an update-assignment operation like <code>+=</code>. (The parentheses are unnecessary.) A more verbose version would be:

<lang e> def newCount := counts.fetch(v, fn { 0 }) + 1

counts[v] := newCount

maxCount := maxCount.max(newCount)</lang>

In for loops, each key and value from the collection are [[Pattern Matching|pattern matched]] against the specified <code><var>key pattern</var> => <var>value pattern</var></code>. In "<code>for v => ==maxCount in counts</code>", the <code>==</code> is a pattern-match operator which fails unless the value examined is equal to the specified value; so this selects only the input values (keys in <code>counts</code>) whose counts are equal to the maximum count.

 

=={{header|Elena}}==

<lang elena>#define std'dictionary'*.

#define std'basic'*.

'program'output << "mode of (" << anArray1 << ") is (" << aMode1 << ")%n".

'program'output << "mode of (" << anArray2 << ") is (" << aMode2 << ")%n".

 

=={{header|Euphoria}}==

constant s = { 1, "blue", 2, 7.5, 5, "green", "red", 5, 2, "blue", "white" }

pretty_print(1,mode(s),{3})</lang>

<pre>{

"blue",

> mode [1;2;1;3;2;0;0];;

val it : int list = [0; 2; 1]</lang>

=={{header|Factor}}==

Factor has the word <code>mode</code> in <code>math.statistics</code> vocabulary.

<lang factor>{ 11 9 4 9 4 9 } mode ! 9 </lang>

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

For the <tt>Qsort_Module</tt> see [[Sorting_algorithms/Quicksort#Fortran]]

<lang fortran>program mode_test

mode xs = keys (filter (== maximum (elems counts)) counts)

where counts = foldr (\x -> insertWith' (+) x 1) empty xs</lang>

''counts'' is a map from each value found in ''xs'' to the number of occurrences (foldr traverses the list, insertWith' increments the count). This map is then filtered to only those entries whose count is the maximum count, and their keys (the values from the input list) are returned.

> mode [1,2,3,3,2,1,1]

[1]

> mode [1,2,3,3,2,1]

[1,2,3]

Alternately:

<lang haskell>import Data.List (group, sort)

where counts = map (\l -> (head l, length l)) . group . sort $ xs

best = maximum (map snd counts)</lang>

Another version that does not require an orderable type:

<lang haskell>import Data.List (partition)

where (xs, notxs) = partition (== x) l

(best, modes) = modesWithCount notxs</lang>

=={{header|GAP}}==

<lang gap>mode := function(v)

mode([ 7, 5, 6, 1, 5, 5, 7, 12, 17, 6, 6, 5, 12, 3, 6 ]);

# [ 5, 6 ]</lang>

=={{header|Go}}==

<lang go>package main

keys.findAll { m[it] == m[keys[0]] }

}</lang>

Test:

<lang groovy>def random = new Random()

println "${mode(a)} == mode(${a})"

}</lang>

<pre>[pattern] == mode([pattern, pattern, pattern, Lamp, pattern, Fri Oct 28 23:43:20 CDT 2011, java.awt.Color[r=255,g=0,b=0], Lamp, Lamp, Lamp, pattern])

[Lamp] == mode([Lamp, Fri Oct 28 23:43:20 CDT 2011, Lamp, java.awt.Color[r=255,g=0,b=0], 42.0, java.awt.Color[r=255,g=0,b=0], Fri Oct 28 23:43:20 CDT 2011, Lamp, pattern, pattern, 42.0])

 

=={{header|Icon}} and {{header|Unicon}}==

<lang icon>procedure main(args)

every write(!mode(args))

}

end</lang>

<pre>->am 3 1 4 1 5 9 7 6

1

=={{header|J}}==

<lang j>mode=: ~. #~ ( = >./ )@( #/.~ )</lang>

Example:

 

=={{header|Java}}==

=={{header|Mathematica}}==

Built-in function commonest returns a '''list''' of the most common element(s), even is there is only one 'commonest' number. Example for multiple 'commonest' numbers and a single 'commonest' number:

gives back:

 

=={{header|MATLAB}}==

else acc)

seen []</lang>

# mode [1;3;6;6;6;6;7;7;12;12;17];;

- : int list = [6]

=={{header|Octave}}==

Of course Octave has the <tt>mode</tt> function; but it returns only the "lowest" mode if multiple modes are available.

<lang octave>function m = mode2(v)

sv = sort(v);

endwhile

endfunction</lang>

<lang octave>a = [1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17];

mode2(a)

=={{header|Perl 6}}==

{{works with|Rakudo|#22 "Thousand Oaks"}}

<lang perl6>sub mode (@a) {

my %counts;

(maxi cdar

(by cdr group A) ) ) ) )</lang>

<pre>: (modes (1 3 6 6 6 6 7 7 12 12 17))

-> (6)

: (modes (1 4 A 3 2 7 1 B B 3 6 2 4 C C 5 2 5 B A 3 2 C 3 5 5 4 C 7 7))

-> (5 C 2 3)</pre>

=={{header|PowerShell}}==

<lang PowerShell>$data = @(1,1,1,2,3,4,5,5,6,7,7,7)

$groups = $data | group-object | sort-object count -Descending

$groups | ? {$_.Count -eq $groups[0].Count}</lang>

<pre>Count Name Group

----- ---- -----

>>> modes((1,1,2,4,4))

[1, 4]</lang>

{{works with|Python|2.7+ and 3.1+}}

<lang python>>>> from collections import Counter

>>> modes((1,1,2,4,4))

[1, 4]</lang>

If you just want one mode (instead of all of them), here's a one-liner for that:

<lang python>def onemode(values):

 

=={{header|REXX}}==

 

/*--------vector---------- ---show vector--- ----show result------ */

end

 

vector=1 8 6 0 1 9 4 6 1 9 9 9

mode=9

p mode_one_pass([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17]) # => [6]

p mode_one_pass([1, 1, 2, 4, 4]) # => [1, 4]</lang>

{{works with|Ruby|1.8.7}}

If you just want one mode (instead of all of them), here's a one-liner for that:

<lang ruby>def one_mode(ary)

=={{header|Scala}}==

{{works with|Scala|2.8}}

Receiving any collection is easy. Returning the result in the same collection takes some doing.

<lang scala>import scala.collection.breakOut

import scala.collection.generic.CanBuildFrom

 

=={{header|Scheme}}==

{{works with|Berkeley Scheme}}

<lang scheme>(define (mode collection)

(define (helper collection counts)

 

=={{header|Slate}}==

[| sortedCounts |

sortedCounts: (s as: Bag) sortedCounts.

(sortedCounts mapSelect: [| :count :elem | sortedCounts last count = count]) valueSet

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

This code is able to find the mode of any collection of any kind of object.

<lang smalltalk>OrderedCollection extend [

puts [mode 1 1 2 4 4]; # --> 1 4</lang>

Note that this works for any kind of value.

=={{header|UNIX Shell}}==

{{works with|bash|4.0}}

<lang bash>mode 1 2 1 2 a b a b a 2

a 2</lang>

=={{header|Ursala}}==

<lang Ursala>#import std

 

 

examples = mode~~ (<1,3,6,6,6,7,7,12,12,17>,<1,1,2,4,4>)</lang>

<pre>(<6>,<4,1>)</pre>

 

The "mode" item and it's count are displayed on status line.

If there are multiple items with the same count, the smallest one is displayed.

Reg_Copy(10, ALL)

Buf_Switch(Buf_Free)

Reg_Copy_Block(10, CP, EOL_pos)

Buf_Quit(OK)

=={{header|XEmacs Lisp}}==

This returns a list of the modes. Any type(s) of data can be passed in, and any "equal" predicate function can be specified.

<lang xelisp>(defun mode ( predicate &rest values)

"Finds the mode of all values passed in.

(when (eq count mode-count)

(push value modes))))