Averages/Root mean square: Difference between revisions

{{task}}

 

 

Compute the   [[wp:Root mean square|Root mean square]]   of the numbers 1..10.

 

 

 

{{Related tasks/Statistical measures}}

=={{header|11l}}==

{{trans|Python}}

R sqrt(sum(num.map(n -> n * n)) / Float(num.len))

 

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

BYTE FUNC Equal(REAL POINTER a,b)

 

=={{header|Ada}}==

with Ada.Numerics.Elementary_Functions;

use Ada.Numerics.Elementary_Functions;

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards)}}

MODE RMSFIELD = #LONG...# REAL;

PROC (RMSFIELD)RMSFIELD rms field sqrt = #long...# sqrt;

=={{header|ALGOL-M}}==

Because ALGOL-M lacks a built-in square root function, we have to supply our own.

BEGIN

 

 

=={{header|ALGOL W}}==

% computes the root-mean-square of an array of numbers with %

% the specified lower bound (lb) and upper bound (ub) %

 

=={{header|APL}}==

x←⍳10

 

 

=={{header|AppleScript}}==

{{Trans|JavaScript}}( ES6 version )

on rootMeanSquare(xs)

script

 

 

on run

 

 

 

-- foldl :: (a -> b -> a) -> a -> [b] -> a

{{Out}}

<pre>6.204836822995</pre>

 

=={{header|Arturo}}==

 

sqrt (sum map arr 'i -> i^2) // size arr

 

 

=={{header|Astro}}==

 

=={{header|AutoHotkey}}==

===Using a loop===

 

 

We can show that:<br>

<math>\sum_{i=a}^b i^2 = \frac{b(b+1)(2b+1)-a(a-1)(2a-1)}{6}</math>

 

 

 

=={{header|AWK}}==

# computes RMS of the 1st column of a data file

{

Note that this will work in [[Visual Basic]] and the Windows versions of [[PowerBASIC]] by simply wrapping the module-level code into the <code>MAIN</code> function, and changing <code>PRINT</code> to <code>MSGBOX</code>.

 

FOR L0 = 1 TO 10

i(L0) = L0

==={{header|Applesoft BASIC}}===

 

20 FOR I = 1 TO N

30 S = S + I * I

{{out}}

<pre>6.20483683</pre>

 

==={{header|IS-BASIC}}===

110 DEF RMS(N)

120 LET R=0

 

==={{header|Sinclair ZX81 BASIC}}===

20 LET RMS=0

30 FOR X=1 TO 10

 

==={{header|BBC BASIC}}===

array() = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

=={{header|BQN}}==

RMS is a tacit function which computes root mean square.

 

RMS 1+↕10</syntaxhighlight>

 

[https://mlochbaum.github.io/BQN/try.html#code=Uk1TIOKGkCDiiJorwrTiiJjDl8ucw7fiiaAKClJNUyAxK+KGlTEw Try It!]

 

Another solution is to take the arithmetic mean <code>+´÷≠</code> under the square (<code>ט</code>) function. Under (<code>⌾</code>) squares the arguments, then applies the mean, then inverts the square function.

 

=={{header|C}}==

#include <math.h>

 

 

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

 

namespace rms

An alternative method demonstrating the more functional style introduced by LINQ and lambda expressions in C# 3.

{{works with|C sharp|C#|3}}

using System.Collections.Generic;

using System.Linq;

 

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

#include <vector>

#include <cmath>

 

=={{header|Clojure}}==

(defn rms [xs]

(Math/sqrt (/ (reduce + (map #(* % %) xs))

=={{header|COBOL}}==

Could be written more succinctly, with an inline loop and more <tt>COMPUTE</tt> statements; but that wouldn't be very COBOLic.

PROGRAM-ID. QUADRATIC-MEAN-PROGRAM.

DATA DIVISION.

=={{header|CoffeeScript}}==

{{trans|JavaScript}}

sum_of_squares = ary.reduce ((s,x) -> s + x*x), 0

return Math.sqrt(sum_of_squares / ary.length)

 

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

for xx = (* x x)

for n from 1

Here's a non-iterative solution.

 

(defun root-mean-square (numbers)

"Takes a list of numbers, returns their quadratic mean."

=={{header|Crystal}}==

{{trans|Ruby}}

Math.sqrt(seq.sum { |x| x*x } / seq.size)

end

 

=={{header|D}}==

 

real rms(R)(R d) pure {

 

=={{header|Delphi}}/{{header|Pascal}}==

 

{$APPTYPE CONSOLE}

=={{header|E}}==

Using the same generic mean function as used in [[../Pythagorean means#E|pythagorean means]]:

return def mean(numbers) {

var count := 0

def RMS := makeMean(0, fn b,x { b+x**2 }, fn acc,n { (acc/n).sqrt() })</syntaxhighlight>

 

# value: 6.2048368229954285</syntaxhighlight>

 

=={{header|EchoLisp}}==

(define (rms xs)

(sqrt (// (for/sum ((x xs)) (* x x)) (length xs))))

=={{header|Elena}}==

{{trans|C#}}

import system'routines;

import system'math;

{

get RootMeanSquare()

}

 

=={{header|Elixir}}==

defmodule RC do

def root_mean_square(enum) do

 

=={{header|Emacs Lisp}}==

(sqrt (/ (apply '+ (mapcar (lambda (x) (* x x)) nums))

(float (length nums)))))

 

=={{header|Erlang}}==

math:sqrt(lists:foldl(fun(E,S) -> S+E*E end, 0, Nums) / length(Nums)).

 

 

=={{header|ERRE}}==

PROGRAM ROOT_MEAN_SQUARE

BEGIN

 

=={{header|Euphoria}}==

atom sum

if length(s) = 0 then

===Cell reference expression===

If values are entered in the cells A1 to A10, the below expression will give the RMS value

=SQRT(SUMSQ($A1:$A10)/COUNT($A1:$A10))

</syntaxhighlight>

{{Works with|Office 365 betas 2021}}

 

=LAMBDA(xs,

SQRT(SUMSQ(xs)/COUNT(xs))

For this test, we assume that the following generic lambda is also bound to the name ENUMFROMTO in the Name Manager:

 

=LAMBDA(a,

LAMBDA(z,

=={{header|F Sharp|F#}}==

Uses a lambda expression and function piping.

 

let res = RMS [1.0..10.0]</syntaxhighlight>

 

=={{header|Factor}}==

[ [ sq ] map-sum ] [ length ] bi / sqrt ;</syntaxhighlight>

 

 

=={{header|Fantom}}==

{

static Float averageRms (Float[] nums)

 

=={{header|Forth}}==

dup >r 0e

floats bounds do

=={{header|Fortran}}==

Assume <math> x </math> stored in array x.

 

=={{header|FreeBASIC}}==

' FB 1.05.0 Win64

 

=={{header|Futhark}}==

 

import "futlib/math"

 

 

=={{header|GEORGE}}==

1, 10 rep (i)

i i | (v) ;

 

=={{header|Go}}==

 

import (

=={{header|Groovy}}==

Solution:

list == null \

? null \

}</syntaxhighlight>

Test:

def Q = quadMean(list)

println """

=={{header|Haskell}}==

Given the <code>mean</code> function defined in [[Averages/Pythagorean means]]:

 

Or, writing a naive '''mean''' of our own, (but see https://donsbot.wordpress.com/2008/06/04/haskell-as-fast-as-c-working-at-a-high-altitude-for-low-level-performance/):

 

 

rootMeanSquare :: [Double] -> Double

 

=={{header|HicEst}}==

DO i = 1, 10

sum = sum + i^2

 

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

every put(x := [], 1 to 10)

writes("x := [ "); every writes(!x," "); write("]")

 

 

local m

if *L = 0 then fail

 

=={{header|Io}}==

 

rms( Range 1 to(10) asList ) println</syntaxhighlight>

=={{header|J}}==

'''Solution:'''

 

'''Example Usage:'''

6.20484</syntaxhighlight>

<code>*:</code> means [http://jsoftware.com/help/dictionary/d112.htm square]

 

=={{header|Java}}==

 

public static double rootMeanSquare(double... nums) {

{{works with|JavaScript|1.8}}

{{works with|Firefox|3.0}}

var sum_of_squares = ary.reduce(function(s,x) {return (s + x*x)}, 0);

return Math.sqrt(sum_of_squares / ary.length);

===ES6===

 

'use strict';

=={{header|jq}}==

The following filter returns ''null'' if given an empty array:

| if $length == 0 then null

else map(. * .) | add | sqrt / $length

 

=={{header|Julia}}==

There are a variety of ways to do this via built-in functions in Julia, given an array <code>A = [1:10]</code> of values. The formula can be implemented directly as:

or shorter with using Statistics (and as spoken: root-mean-square)

One can also use an explicit loop for near-C performance

function rms(A)

s = 0.0

end

</syntaxhighlight>

 

=={{header|K}}==

rms:{_sqrt (+/x^2)%#x}

rms 1+!10

 

=={{header|Kotlin}}==

 

fun quadraticMean(vector: Array<Double>) : Double {

Quadratic mean of numbers 1 to 10 is 6.2048368229954285

</pre>

 

=={{header|Lasso}}==

return math_sqrt((with n in #a sum #n*#n) / decimal(#a->size))

}

 

=={{header|Liberty BASIC}}==

 

SourceList$ ="1 2 3 4 5 6 7 8 9 10"

 

=={{header|Logo}}==

output sqrt quotient (apply "sum map [? * ?] :v) count :v

end

 

=={{header|Lua}}==

function rms(t) return (sumsq(unpack(t)) / #t)^.5 end

 

 

=={{header|Maple}}==

RMS := proc( x )

return sqrt( Statistics:-Mean( x ^~ 2 ) );

 

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

The above will give the precise solution <math>\sqrt{\frac{77}{2}}</math>, to downgrade to 6.20484, use '<code>10.</code>' to imply asking for numeric solution, or append '<code>//N</code>' after the whole expression.

 

=={{header|MATLAB}}==

rms = sqrt(mean(list.^2));

end</syntaxhighlight>

Solution:

 

ans =

 

=={{header|Maxima}}==

 

rms(L) := sqrt(lsum(x^2, x, L)/length(L))$

 

=={{header|MAXScript}}==

fn RMS arr =

(

</syntaxhighlight>

Output:

rms #{1..10}

6.20484

 

=={{header|min}}==

 

(1 2 3 4 5 6 7 8 9 10) rms puts!</syntaxhighlight>

{{out}}

 

=={{header|МК-61/52}}==

+ ИП1 1 + П1 / КвКор П0 БП

03</syntaxhighlight>

=={{header|Morfa}}==

{{trans|D}}

import morfa.base;

import morfa.functional.base;

 

=={{header|Nemerle}}==

using System.Console;

using System.Math;

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

 

=={{header|Nim}}==

from sequtils import mapIt

=={{header|Oberon-2}}==

Oxford Oberon-2

MODULE QM;

IMPORT ML := MathL, Out;

 

=={{header|Objeck}}==

class Hello {

function : Main(args : String[]) ~ Nil {

 

=={{header|OCaml}}==

sqrt (Array.fold_left (fun s x -> s +. x*.x) 0.0 a /.

float_of_int (Array.length a))

=={{header|Oforth}}==

 

 

{{out}}

 

=={{header|ooRexx}}==

call testAverage .array~of(10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, .11)

call testAverage .array~of(30, 10, 20, 30, 40, 50, -100, 4.7, -11e2)

 

=={{header|Oz}}==

fun {Square X} X*X end

 

=={{header|PARI/GP}}==

General RMS calculation:

sqrt(sum(i=1,#v,v[i]^2)/#v)

};

 

Specific functions for the first ''n'' positive integers:

sqrt((n+1)*(2*n+1)/6)

};

 

=={{header|Perl}}==

sub rms

{

 

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">rms</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">atom</span> <span style="color: #000000;">sqsum</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>

Alternative, same output<br>

You could make this a one-liner, for no gain and making it harder to debug - an explicitly named intermediate such as sqsum adds no additional overhead compared to the un-named hidden temporary variable the compiler would otherwise use anyway, and of course sqsum can be examined/verified to pinpoint any error more effectively. The last (commented-out) line also removes the function call, but of course it has also removed every last descriptive hint of what it is supposed to be doing as well.

<span style="color: #008080;">function</span> <span style="color: #000000;">rms</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">atom</span> <span style="color: #000000;">sqsum</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">power</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">}))</span>

 

=={{header|Phixmonti}}==

0 swap

len for

 

=={{header|PHP}}==

// Created with PHP 7.0

 

{{trans|Prolog}}

{{works with|Picat}}

rms(Xs) = Y =>

Sum = sum_of_squares(Xs),

 

=={{header|PicoLisp}}==

 

(let Lst (1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0)

 

=={{header|PL/I}}==

declare A(10) Dec Float(15) static initial (1,2,3,4,5,6,7,8,9,10);

declare (n,RMS) Dec Float(15);

 

=={{header|PostScript}}==

/x exch def

/sum 0 def

</pre>

{{libheader|initlib}}

 

=={{header|Potion}}==

total = 0.0

series each (x): total += x * x.

 

=={{header|Powerbuilder}}==

decimal ld_rms

 

 

=={{header|PowerShell}}==

$sqsum=$nums | foreach-object { $_*$_} | measure-object -sum | select-object -expand Sum

return [math]::sqrt($sqsum/$nums.count)

 

=={{header|Processing}}==

float[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

print(rms(numbers));

=={{header|Prolog}}==

{{works with|GNU Prolog}}

:- initialization(main).

 

 

=={{header|PureBasic}}==

 

If OpenConsole()

=={{header|Python}}==

{{works with|Python|3}}

>>> def qmean(num):

return sqrt(sum(n*n for n in num)/len(num))

 

Alternatively in terms of '''reduce''':

from math import (sqrt)

 

 

=={{header|Qi}}==

R -> (sqrt (/ (APPLY + (MAPCAR * R R)) (length R))))</syntaxhighlight>

 

Using the Quackery big number rational arithmetic library <code>bigrat.qky</code>.

 

 

[ [] swap

 

The following function works for any vector x:

 

RMS(1:10)

 

=={{header|Racket}}==

#lang racket

(define (rms nums)

=={{header|Raku}}==

(formerly Perl 6)

 

say rms 1..10;</syntaxhighlight>

 

Here's a slightly more concise version, albeit arguably less readable:

 

=={{header|REXX}}==

<br>calculation as well as a reasonable attempt at providing a first-guess square root by essentially halving

<br>the number using logarithmic (base ten) arithmetic.

parse arg nums digs show . /*obtain the optional arguments from CL*/

if nums=='' | nums=="," then nums=10 /*Not specified? Then use the default.*/

 

=={{header|Ring}}==

nums = [1,2,3,4,5,6,7,8,9,10]

sum = 0

return x

</syntaxhighlight>

 

=={{header|Ruby}}==

def quadratic_mean

Math.sqrt( self.inject(0.0) {|s, y| s + y*y} / self.length )

 

and a non object-oriented solution:

Math.sqrt(seq.sum{|x| x*x}.fdiv(seq.size) )

end

 

=={{header|Run BASIC}}==

while word$(valueList$,i +1) <> "" ' grab values from list

thisValue = val(word$(valueList$,i +1)) ' turn values into numbers

 

=={{header|Rust}}==

let sum_squares = vec.iter().fold(0, |acc, &x| acc + x.pow(2));

return ((sum_squares as f32)/(vec.len() as f32)).sqrt();

built-in syntax.

 

{

return sqrt(sum(sqr(arr)) / length(arr));

 

=={{header|Sather}}==

-- irrms stands for Integer Ranged RMS

irrms(i, f:INT):FLT

 

=={{header|S-BASIC}}==

var n, sqsum, sqmean, rms = real

sqsum = 0

 

=={{header|Scala}}==

println(rms(1 to 10))</syntaxhighlight>

{{out}}

 

=={{header|Scheme}}==

(sqrt (/ (apply + (map * nums nums))

(length nums))))

 

=={{header|Seed7}}==

include "float.s7i";

include "math.s7i";

=={{header|Shen}}==

{{works with|shen-scheme|0.17}}

 

(tc +)

 

=={{header|Sidef}}==

sqrt(a.map{.**2}.sum / a.len)

}

 

Using hyper operators, we can write it as:

 

{{out}}

 

=={{header|Smalltalk}}==

 

=={{header|SNOBOL4}}==

{{works with|CSnobol}}

There is no built-in sqrt( ) function in Snobol4+.

rms i = i + 1; ssq = ssq + (a<i> * a<i>) :s(rms)

rms = sqrt(1.0 * ssq / prototype(a)) :(return)

{{out}}

<pre>1 2 3 4 5 6 7 8 9 10 -> 6.20483682</pre>

 

=={{header|Standard ML}}==

let

val v' = Vector.map (fn x => x*x) v

Compute the RMS of a variable and return the result in r(rms).

 

syntax varname(numeric) [if] [in]

tempvar x

'''Example'''

 

set obs 20

gen x=rnormal()

=={{header|Swift}}==

 

@inlinable

public func rms() -> Element {

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

set sum 0.0

foreach value $list { set sum [expr {$sum + $value**2}] }

=={{header|Ursala}}==

using the <code>mean</code> function among others from the <code>flo</code> library

#import flo

 

=={{header|Vala}}==

Valac probably needs to have the flag "-X -lm" added to include the C Math library.

double sum_squares = 0;

double mean;

=={{header|VBA}}==

Using Excel VBA

For i = 1 To UBound(s)

s(i) = s(i) ^ 2

End Sub</syntaxhighlight>

Without using Excel worksheetfunction:

Dim i As Integer

If iLow > iHigh Then

</pre>

 

fn main() {

 

=={{header|Wortel}}==

; using a composition and a fork (like you would do in J)

rms1 ^(@sqrt @(@sum / #) *^@sq)

 

=={{header|Wren}}==

System.print(rms)</syntaxhighlight>

 

 

=={{header|XLISP}}==

(sqrt

(/

 

=={{header|XPL0}}==

code real RlOut=48;

int N;

 

=={{header|Yacas}}==

The above will give the precise solution <math>\sqrt{\frac{77}{2}}</math>, to downgrade to 6.20483682299, surround the expression with '<code>N()</code>'.

 

=={{header|zkl}}==

The order in the reduce function is important as it coerces n*n to float.

<pre>