# Averages/Root mean square

You are encouraged to solve this task according to the task description, using any language you may know.

Compute the   Root mean square   of the numbers 1..10.

The   root mean square   is also known by its initials RMS (or rms), and as the quadratic mean.

The RMS is calculated as the mean of the squares of the numbers, square-rooted:

$x_{\mathrm {rms} }={\sqrt {{{x_{1}}^{2}+{x_{2}}^{2}+\cdots +{x_{n}}^{2}} \over n}}.$ ## 11l

Translation of: Python
F qmean(num)
R sqrt(sum(num.map(n -> n * n)) / Float(num.len))

print(qmean(1..10))
Output:
6.20484


## Action!

INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit

BYTE FUNC Equal(REAL POINTER a,b)
BYTE ARRAY x,y

x=a y=b
IF x(0)=y(0) AND x(1)=y(1) AND x(2)=y(2) THEN
RETURN (1)
FI
RETURN (0)

PROC Sqrt(REAL POINTER a,b)
REAL z,half

IntToReal(0,z)
ValR("0.5",half)

IF Equal(a,z) THEN
RealAssign(z,b)
ELSE
Power(a,half,b)
FI
RETURN

PROC Main()
BYTE i
REAL x,x2,sum,tmp

IntToReal(0,sum)
FOR i=1 TO 10
DO
IntToReal(i,x)
RealMult(x,x,x2)
RealAssign(tmp,sum)
OD
IntToReal(10,x)
RealDiv(sum,x,tmp)
Sqrt(tmp,x)

Put(125) PutE() ;clear screen
Print("RMS of 1..10 is ")
PrintRE(x)
RETURN
Output:
RMS of 1..10 is 6.20483663


with Ada.Float_Text_IO; use Ada.Float_Text_IO;
procedure calcrms is
type float_arr is array(1..10) of Float;

function rms(nums : float_arr) return Float is
sum : Float := 0.0;
begin
for p in nums'Range loop
sum := sum + nums(p)**2;
end loop;
return sqrt(sum/Float(nums'Length));
end rms;

list : float_arr;
begin
list := (1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0);
put( rms(list) , Exp=>0);
end calcrms;

Output:
 6.20484


## ALGOL 68

Works with: ALGOL 68 version Standard - no extensions to language used
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny
Works with: ELLA ALGOL 68 version Any (with appropriate job cards)
# Define the rms PROCedure & ABS OPerators for LONG... REAL #
MODE RMSFIELD = #LONG...# REAL;
PROC (RMSFIELD)RMSFIELD rms field sqrt = #long...# sqrt;
INT rms field width = #long...# real width;

PROC crude rms = ([]RMSFIELD v)RMSFIELD: (
RMSFIELD sum := 0;
FOR i FROM LWB v TO UPB v DO sum +:= v[i]**2 OD;
rms field sqrt(sum / (UPB v - LWB v + 1))
);

PROC rms = ([]RMSFIELD v)RMSFIELD: (
# round off error accumulated at standard precision #
RMSFIELD sum := 0, round off error:= 0;
FOR i FROM LWB v TO UPB v DO
RMSFIELD org = sum, prod = v[i]**2;
sum +:= prod;
round off error +:= sum - org - prod
OD;
rms field sqrt((sum - round off error)/(UPB v - LWB v + 1))
);

main: (
[]RMSFIELD one to ten = (1,2,3,4,5,6,7,8,9,10);

print(("crude rms(one to ten): ", crude rms(one to ten), new line));
print(("rms(one to ten): ",       rms(one to ten), new line))
)
Output:
crude rms(one to ten): +6.20483682299543e  +0
rms(one to ten): +6.20483682299543e  +0


## ALGOL-M

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

BEGIN

DECIMAL FUNCTION SQRT(X);
DECIMAL X;
BEGIN
DECIMAL R1, R2, TOL;
TOL := .00001;   % reasonable for most purposes %
IF X >= 1.0 THEN
BEGIN
R1 := X;
R2 := 1.0;
END
ELSE
BEGIN
R1 := 1.0;
R2 := X;
END;
WHILE (R1-R2) > TOL DO
BEGIN
R1 := (R1+R2) / 2.0;
R2 := X / R1;
END;
SQRT := R1;
END;

COMMENT - MAIN PROGRAM BEGINS HERE;

DECIMAL N, SQSUM, SQMEAN;

SQSUM := 0.0;
FOR N := 1.0 STEP 1.0 UNTIL 10.0 DO
SQSUM := SQSUM + (N * N);
SQMEAN := SQSUM / (N - 1.0);
WRITE("RMS OF WHOLE NUMBERS 1.0 THROUGH 10.0 =", SQRT(SQMEAN));

END
Output:

Based on the limited precision of the square root function, only the first six decimal places of the output can actually be relied on (but that's more than sufficient for most real world uses).

RMS OF WHOLE NUMBERS 1.0 THROUGH 10.0 = 6.20483683432


## ALGOL W

begin
% computes the root-mean-square of an array of numbers with               %
% the specified lower bound (lb) and upper bound (ub)                     %
real procedure rms( real    array numbers ( * )
; integer value lb
; integer value ub
) ;
begin
real sum;
sum := 0;
for i := lb until ub do sum := sum + ( numbers(i) * numbers(i) );
sqrt( sum / ( ( ub - lb ) + 1 ) )
end rms ;

% test the rms procedure with the numbers 1 to 10                         %
real array testNumbers( 1 :: 10 );
for i := 1 until 10 do testNumbers(i) := i;
r_format := "A"; r_w := 10; r_d := 4; % set fixed point output           %
write( "rms of 1 .. 10: ", rms( testNumbers, 1, 10 ) );

end.
Output:
rms of 1 .. 10:     6.2048


## APL

 rms←{((+/⍵*2)÷⍴⍵)*0.5}
x←⍳10

rms x
6.204836823


## AppleScript

### Functional

Translation of: JavaScript
( ES6 version )
--------------------- ROOT MEAN SQUARE -------------------

-- rootMeanSquare :: [Num] -> Real
on rootMeanSquare(xs)
script
on |λ|(a, x)
a + x * x
end |λ|
end script

(foldl(result, 0, xs) / (length of xs)) ^ (1 / 2)
end rootMeanSquare

--------------------------- TEST -------------------------
on run

rootMeanSquare({1, 2, 3, 4, 5, 6, 7, 8, 9, 10})

-- > 6.204836822995
end run

-------------------- GENERIC FUNCTIONS -------------------

-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
tell mReturn(f)
set v to startValue
set lng to length of xs
repeat with i from 1 to lng
set v to |λ|(v, item i of xs, i, xs)
end repeat
return v
end tell
end foldl

-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
if class of f is script then
f
else
script
property |λ| : f
end script
end if
end mReturn

Output:
6.204836822995

### Straightforward

on rootMeanSquare(listOfNumbers)
script o
property lst : listOfNumbers
end script
set r to 0.0
repeat with n in o's lst
set r to r + (n ^ 2)
end repeat

return (r / (count o's lst)) ^ 0.5
end rootMeanSquare

rootMeanSquare({1, 2, 3, 4, 5, 6, 7, 8, 9, 10})

Output:
6.204836822995


### Integer range alternative

Translation of: AutoHotKey
("Avoiding a loop" solution)
-- RMS of integer range a to b.
on rootMeanSquare(a, b)
return ((b * (b + 1) * (2 * b + 1) - a * (a - 1) * (2 * a - 1)) / 6 / (b - a + 1)) ^ 0.5
end rootMeanSquare

rootMeanSquare(1, 10)

Output:
6.204836822995


## Arturo

rootMeanSquare: function [arr]->
sqrt (sum map arr 'i -> i^2) // size arr

print rootMeanSquare 1..10

Output:
6.204836822995428

## Astro

sqrt(mean(x²))


## AutoHotkey

### Using a loop

MsgBox, % RMS(1, 10)

;---------------------------------------------------------------------------
RMS(a, b) { ; Root Mean Square of integers a through b
;---------------------------------------------------------------------------
n := b - a + 1
Loop, %n%
Sum += (a + A_Index - 1) ** 2
Return, Sqrt(Sum / n)
}


Message box shows:

6.204837


### Avoiding a loop

Using these equations:
$\sum _{i=1}^{n}i^{2}={\frac {n(n+1)(2n+1)}{6}}$ See wp:List of mathematical series

for $a : $\sum _{i=a}^{b}i^{2}=\sum _{i=1}^{b}i^{2}-\sum _{i=1}^{a-1}i^{2}$ We can show that:
$\sum _{i=a}^{b}i^{2}={\frac {b(b+1)(2b+1)-a(a-1)(2a-1)}{6}}$ MsgBox, % RMS(1, 10)

;---------------------------------------------------------------------------
RMS(a, b) { ; Root Mean Square of integers a through b
;---------------------------------------------------------------------------
Return, Sqrt((b*(b+1)*(2*b+1)-a*(a-1)*(2*a-1))/6/(b-a+1))
}


Message box shows:

6.204837


## AWK

#!/usr/bin/awk -f
# computes RMS of the 1st column of a data file
{
x  = $1; # value of 1st column S += x*x; N++; } END { print "RMS: ",sqrt(S/N); }  ## BASIC Works with: QBasic Note that this will work in Visual Basic and the Windows versions of PowerBASIC by simply wrapping the module-level code into the MAIN function, and changing PRINT to MSGBOX. DIM i(1 TO 10) AS DOUBLE, L0 AS LONG FOR L0 = 1 TO 10 i(L0) = L0 NEXT PRINT STR$(rms#(i()))

FUNCTION rms# (what() AS DOUBLE)
DIM L0 AS LONG, tmp AS DOUBLE, rt AS DOUBLE
FOR L0 = LBOUND(what) TO UBOUND(what)
rt = rt + (what(L0) ^ 2)
NEXT
tmp = UBOUND(what) - LBOUND(what) + 1
rms# = SQR(rt / tmp)
END FUNCTION


### Applesoft BASIC

 10 N = 10
20  FOR I = 1 TO N
30 S = S + I * I
40  NEXT
50 X =  SQR (S / N)
60  PRINT X
Output:
6.20483683

### Craft Basic

precision 8

let n = 10

for i = 1 to n

let s = s + i * i

next i

print sqrt(s / n)

Output:
6.20483682

### IS-BASIC

100 PRINT RMS(10)
110 DEF RMS(N)
120   LET R=0
130   FOR X=1 TO N
140     LET R=R+X^2
150   NEXT
160   LET RMS=SQR(R/N)
170 END DEF

### Sinclair ZX81 BASIC

10 FAST
20 LET RMS=0
30 FOR X=1 TO 10
40 LET RMS=RMS+X**2
50 NEXT X
60 LET RMS=SQR (RMS/10)
70 SLOW
80 PRINT RMS

Output:
6.2048368

### BBC BASIC

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

PRINT FNrms(array())
END

DEF FNrms(a()) = MOD(a()) / SQR(DIM(a(),1)+1)


## BQN

RMS is a tacit function which computes root mean square.

RMS ← √+´∘×˜÷≠

RMS 1+↕10

6.2048368229954285


Another solution is to take the arithmetic mean +´÷≠ under the square (×˜) function. Under (⌾) squares the arguments, then applies the mean, then inverts the square function.

RMS ← (+´÷≠)⌾(×˜)


## C

#include <stdio.h>
#include <math.h>

double rms(double *v, int n)
{
int i;
double sum = 0.0;
for(i = 0; i < n; i++)
sum += v[i] * v[i];
return sqrt(sum / n);
}

int main(void)
{
double v[] = {1., 2., 3., 4., 5., 6., 7., 8., 9., 10.};
printf("%f\n", rms(v, sizeof(v)/sizeof(double)));
return 0;
}


## C#

using System;

namespace rms
{
class Program
{
static void Main(string[] args)
{
int[] x = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Console.WriteLine(rootMeanSquare(x));
}

private static double rootMeanSquare(int[] x)
{
double sum = 0;
for (int i = 0; i < x.Length; i++)
{
sum += (x[i]*x[i]);
}
return Math.Sqrt(sum / x.Length);
}
}
}


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

Works with: C# version 3
using System;
using System.Collections.Generic;
using System.Linq;

namespace rms
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine(rootMeanSquare(Enumerable.Range(1, 10)));
}

private static double rootMeanSquare(IEnumerable<int> x)
{
return Math.Sqrt(x.Average(i => (double)i * i));
}
}
}


## C++

#include <iostream>
#include <vector>
#include <cmath>
#include <numeric>

int main( ) {
std::vector<int> numbers ;
for ( int i = 1 ; i < 11 ; i++ )
numbers.push_back( i ) ;
double meansquare = sqrt( ( std::inner_product( numbers.begin(), numbers.end(), numbers.begin(), 0 ) ) / static_cast<double>( numbers.size() ) );
std::cout << "The quadratic mean of the numbers 1 .. " << numbers.size() << " is " << meansquare << " !\n" ;
return 0 ;
}

Output:
The quadratic mean of the numbers 1 .. 10 is 6.20484 !


## Clojure

(defn rms [xs]
(Math/sqrt (/ (reduce + (map #(* % %) xs))
(count xs))))

(println (rms (range 1 11)))

Output:
6.2048368229954285


## COBOL

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

IDENTIFICATION DIVISION.
DATA DIVISION.
WORKING-STORAGE SECTION.
05 N               PIC 99        VALUE 0.
05 N-SQUARED       PIC 999.
05 RUNNING-TOTAL   PIC 999       VALUE 0.
05 MEAN-OF-SQUARES PIC 99V9(16).
PROCEDURE DIVISION.
CONTROL-PARAGRAPH.
PERFORM MULTIPLICATION-PARAGRAPH 10 TIMES.
DIVIDE  RUNNING-TOTAL BY 10 GIVING MEAN-OF-SQUARES.
STOP RUN.
MULTIPLICATION-PARAGRAPH.
MULTIPLY N         BY N GIVING N-SQUARED.

Output:
6.204836822995428

## CoffeeScript

Translation of: JavaScript
    root_mean_square = (ary) ->
sum_of_squares = ary.reduce ((s,x) -> s + x*x), 0
return Math.sqrt(sum_of_squares / ary.length)



## Common Lisp

(loop for x from 1 to 10
for xx = (* x x)
for n from 1
summing xx into xx-sum
finally (return (sqrt (/ xx-sum n))))


Here's a non-iterative solution.

(defun root-mean-square (numbers)
"Takes a list of numbers, returns their quadratic mean."
(sqrt
(/ (apply #'+ (mapcar #'(lambda (x) (* x x)) numbers))
(length numbers))))

(root-mean-square (loop for i from 1 to 10 collect i))


## Crystal

Translation of: Ruby
def rms(seq)
Math.sqrt(seq.sum { |x| x*x } / seq.size)
end

puts rms (1..10).to_a

Output:
6.2048368229954285

## D

import std.stdio, std.math, std.algorithm, std.range;

real rms(R)(R d) pure {
return sqrt(d.reduce!((a, b) => a + b * b) / real(d.length));
}

void main() {
writefln("%.19f", iota(1, 11).rms);
}

Output:
6.2048368229954282979


## Delphi/Pascal

program AveragesMeanSquare;

}
}

## Forth

: rms ( faddr len -- frms )
dup >r 0e
floats bounds do
i f@ fdup f* f+
float +loop
r> s>f f/ fsqrt ;

create test 1e f, 2e f, 3e f, 4e f, 5e f, 6e f, 7e f, 8e f, 9e f, 10e f,
test 10 rms f.    \ 6.20483682299543


## Fortran

Assume $x$ stored in array x.

print *,sqrt( sum(x**2)/size(x) )


## FreeBASIC

' FB 1.05.0 Win64

Function QuadraticMean(array() As Double) As Double
Dim length As Integer = Ubound(array) - Lbound(array) + 1
Dim As Double sum = 0.0
For i As Integer = LBound(array) To UBound(array)
sum += array(i) * array(i)
Next
Return Sqr(sum/length)
End Function

Dim vector(1 To 10) As Double
For i As Integer = 1 To 10
vector(i) = i
Next

Print
Print "Press any key to quit the program"
Sleep
Output:
Quadratic mean (or RMS) is : 6.204836822995429


## Futhark

import "futlib/math"

fun main(as: [n]f64): f64 =
f64.sqrt ((reduce (+) 0.0 (map (**2.0) as)) / f64(n))


## GEORGE

1, 10 rep (i)
i i | (v) ;
0
1, 10 rep (i)
i dup mult +
]
10 div
sqrt
print
 6.204836822995428


## Go

package main

import (
"fmt"
"math"
)

func main() {
const n = 10
sum := 0.
for x := 1.; x <= n; x++ {
sum += x * x
}
fmt.Println(math.Sqrt(sum / n))
}

Output:
6.2048368229954285


## Groovy

Solution:

def quadMean = { list ->
list == null \
? null \
: list.empty \
? 0 \
: ((list.collect { it*it }.sum()) / list.size()) ** 0.5
}


Test:

def list = 1..10
println """
list: ${list} Q:${Q}
"""

Output:
list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Q: 6.2048368229954285

Given the mean function defined in Averages/Pythagorean means:

main = print $mean 2 [1 .. 10]  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/): import Data.List (genericLength) rootMeanSquare :: [Double] -> Double rootMeanSquare = sqrt . (((/) . foldr ((+) . (^ 2)) 0) <*> genericLength) main :: IO () main = print$ rootMeanSquare [1 .. 10]

Output:
6.2048368229954285

## HicEst

sum = 0
DO i = 1, 10
sum = sum + i^2
ENDDO
WRITE(ClipBoard) "RMS(1..10) = ", (sum/10)^0.5

RMS(1..10) = 6.204836823

## Icon and Unicon

procedure main()
every put(x := [], 1 to 10)
writes("x := [ "); every writes(!x," "); write("]")
end


procedure qmean(L[])             #: quadratic mean
local m
if *L = 0 then fail
every (m := 0.0) +:= !L^2
return sqrt(m / *L)
end


## Io

rms := method (figs, (figs map(** 2) reduce(+) / figs size) sqrt)

rms( Range 1 to(10) asList ) println


## J

Solution:

rms=: (+/ % #)&.:*:


Example Usage:

  rms 1 + i. 10
6.20484


*: means square

(+/ % #) is an idiom for mean.

&.: means under -- in other words, we square numbers, take their average and then use the inverse of square on the result. (see also the page on &. which does basically the same thing but with different granularity -- item at a time instead of everything at once.

## Java

public class RootMeanSquare {

public static double rootMeanSquare(double... nums) {
double sum = 0.0;
for (double num : nums)
sum += num * num;
return Math.sqrt(sum / nums.length);
}

public static void main(String[] args) {
double[] nums = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0};
System.out.println("The RMS of the numbers from 1 to 10 is " + rootMeanSquare(nums));
}
}

Output:
The RMS of the numbers from 1 to 10 is 6.2048368229954285

## JavaScript

### ES5

Works with: JavaScript version 1.8
Works with: Firefox version 3.0
function root_mean_square(ary) {
var sum_of_squares = ary.reduce(function(s,x) {return (s + x*x)}, 0);
return Math.sqrt(sum_of_squares / ary.length);
}

print( root_mean_square([1,2,3,4,5,6,7,8,9,10]) ); // ==> 6.2048368229954285


### ES6

(() => {
'use strict';

// rootMeanSquare :: [Num] -> Real
const rootMeanSquare = xs =>
Math.sqrt(
xs.reduce(
(a, x) => (a + x * x),
0
) / xs.length
);

return rootMeanSquare([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

// -> 6.2048368229954285
})();

Output:
6.2048368229954285

## jq

The following filter returns null if given an empty array:

def rms: length as $length | if$length == 0 then null
else map(. * .) | add | sqrt / $length end ; With this definition, the following program would compute the rms of each array in a file or stream of numeric arrays: rms ## Julia There are a variety of ways to do this via built-in functions in Julia, given an array A = [1:10] of values. The formula can be implemented directly as: sqrt(sum(A.^2.) / length(A))  or shorter with using Statistics (and as spoken: root-mean-square) sqrt(mean(A.^2.))  or the implicit allocation of a new array by A.^2. can be avoided by using sum as a higher-order function: sqrt(sum(x -> x*x, A) / length(A))  One can also use an explicit loop for near-C performance function rms(A) s = 0.0 for a in A s += a*a end return sqrt(s / length(A)) end  Potentially even better is to use the built-in norm function, which computes the square root of the sum of the squares of the entries of A in a way that avoids the possibility of spurious floating-point overflow (if the entries of A are so large that they may overflow if squared): norm(A) / sqrt(length(A))  ## K  rms:{_sqrt (+/x^2)%#x} rms 1+!10 6.204837  ## Kotlin // version 1.0.5-2 fun quadraticMean(vector: Array<Double>) : Double { val sum = vector.sumByDouble { it * it } return Math.sqrt(sum / vector.size) } fun main(args: Array<String>) { val vector = Array(10, { (it + 1).toDouble() }) print("Quadratic mean of numbers 1 to 10 is${quadraticMean(vector)}")
}

Output:
Quadratic mean of numbers 1 to 10 is 6.2048368229954285


## Lambdatalk

{def rms
{lambda {:n}
{sqrt
{/ {+ {S.map {lambda {:i} {* :i :i}}
{S.serie 1 :n}}}
:n}}}}
-> rms

{rms 10}
-> 6.2048368229954285


## Lasso

define rms(a::staticarray)::decimal => {
return math_sqrt((with n in #a sum #n*#n) / decimal(#a->size))
}
rms(generateSeries(1,10)->asStaticArray)

Output:
6.204837

## Liberty BASIC

'   [RC] Averages/Root mean square

SourceList$="1 2 3 4 5 6 7 8 9 10" ' If saved as an array we'd have to have a flag for last data. ' LB has the very useful word$() to read from delimited strings.
'   The default delimiter is a space character, " ".

SumOfSquares    =0
n               =0      '   This holds index to number, and counts number of data.
data$="666" ' temporary dummy to enter the loop. while data$ <>""                                '   we loop until no data left.
data$=word$( SourceList$, n +1) ' first data, as a string NewVal =val( data$)                '   convert string to number
SumOfSquares    =SumOfSquares +NewVal^2     '   add to existing sum of squares
n =n +1                                     '   increment number of data items found
wend

n =n -1

}
}


## NetRexx

/* NetRexx */
options replace format comments java crossref symbols nobinary

parse arg maxV .
if maxV = '' | maxV = '.' then maxV = 10

sum = 0
loop nr = 1 for maxV
sum = sum + nr ** 2
end nr
rmsD = Math.sqrt(sum / maxV)

say 'RMS of values from 1 to' maxV':' rmsD

return
Output:
RMS of values from 1 to 10: 6.204836822995428


## Nim

from math import sqrt, sum
from sequtils import mapIt

proc qmean(num: seq[float]): float =
result = num.mapIt(it * it).sum
result = sqrt(result / float(num.len))

echo qmean(@[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0])

Output:
6.204836822995428

## Oberon-2

Oxford Oberon-2

MODULE QM;
IMPORT ML := MathL, Out;
VAR
nums: ARRAY 10 OF LONGREAL;
i: INTEGER;

PROCEDURE Rms(a: ARRAY OF LONGREAL): LONGREAL;
VAR
i: INTEGER;
s: LONGREAL;
BEGIN
s := 0.0;
FOR i := 0 TO LEN(a) - 1 DO
s := s + (a[i] * a[i])
END;
RETURN ML.Sqrt(s / LEN(a))
END Rms;

BEGIN
FOR i := 0 TO LEN(nums) - 1 DO
nums[i] := i + 1
END;
END QM.
Output:
Quadratic Mean: 6.20483682300


## Objeck

bundle Default {
class Hello {
function : Main(args : String[]) ~ Nil {
values := [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0];
RootSquareMean(values)->PrintLine();
}

function : native : RootSquareMean(values : Float[]) ~ Float {
sum := 0.0;
each(i : values) {
x := values[i]->Power(2.0);
sum += values[i]->Power(2.0);
};

return (sum / values->Size())->SquareRoot();
}
}
}

## OCaml

let rms a =
sqrt (Array.fold_left (fun s x -> s +. x*.x) 0.0 a /.
float_of_int (Array.length a))
;;

rms (Array.init 10 (fun i -> float_of_int (i+1))) ;;
(* 6.2048368229954285 *)


## Oforth

10 seq map(#sq) sum 10.0 / sqrt .
Output:
6.20483682299543


## ooRexx

call testAverage .array~of(10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
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)

::routine testAverage
use arg list
say "list =" list~toString("l", ", ")
say "root mean square =" rootmeansquare(list)
say

::routine rootmeansquare
use arg numbers
-- return zero for an empty list
if numbers~isempty then return 0

sum = 0
do number over numbers
sum += number * number
end
return rxcalcsqrt(sum/numbers~items)

::requires rxmath LIBRARY
Output:
list = 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
root mean square = 6.20483682

list = 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, .11
root mean square = 5.06630766

list = 30, 10, 20, 30, 40, 50, -100, 4.7, -1100
root mean square = 369.146476

## Oz

declare
fun {Square X} X*X end

fun {RMS Xs}
{Sqrt
{Int.toFloat {FoldL {Map Xs Square} Number.'+' 0}}
/
{Int.toFloat {Length Xs}}}
end
in
{Show {RMS {List.number 1 10 1}}}
Output:
6.2048


## PARI/GP

General RMS calculation:

RMS(v)={
sqrt(sum(i=1,#v,v[i]^2)/#v)
};

RMS(vector(10,i,i))

Specific functions for the first n positive integers:

RMS_first(n)={
sqrt((n+1)*(2*n+1)/6)
};

RMS_first(10)

Asymptotically this is n/sqrt(3).

## Perl

use v5.10.0;
sub rms
{
my $r = 0;$r += $_**2 for @_; sqrt($r/@_ );
}

say rms(1..10);


## Phix

function rms(sequence s)
atom sqsum = 0
for i=1 to length(s) do
sqsum += power(s[i],2)
end for
return sqrt(sqsum/length(s))
end function

?rms({1,2,3,4,5,6,7,8,9,10})

Output:
6.204836823


Alternative, same output
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.

function rms(sequence s)
atom sqsum = sum(apply(true,power,{s,2}))
return sqrt(sqsum/length(s))
end function
?rms(tagset(10))
-- ?sqrt(sum(apply(true,power,{tagset(10),2}))/10) -- (ugh)


## Phixmonti

def rms
0 swap
len for
get 2 power rot + swap
endfor
len rot swap / sqrt
enddef

0 tolist
10 for
0 put
endfor

rms print

## PHP

<?php
// Created with PHP 7.0

function rms(array $numbers) {$sum = 0;

foreach ($numbers as$number) {
$sum +=$number**2;
}

return sqrt($sum / count($numbers));
}

echo rms(array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));

Output:
6.2048368229954


## Picat

Translation of: Prolog
Works with: Picat
rms(Xs) = Y =>
Sum = sum_of_squares(Xs),
N = length(Xs),
Y = sqrt(Sum / N).

sum_of_squares(Xs) = Sum =>
Sum = 0,
foreach (X in Xs)
Sum := Sum + X * X
end.

main =>
Y = rms(1..10),
printf("The root-mean-square of 1..10 is %f\n", Y).
Output:
The root-mean-square of 1..10 is 6.204837


## PicoLisp

(scl 5)

(let Lst (1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0)
(prinl
(format
(sqrt
(*/
(sum '((N) (*/ N N 1.0)) Lst)
1.0
(length Lst) )
T )
*Scl ) ) )
Output:
6.20484

## PL/I

 atest: Proc Options(main);
declare A(10) Dec Float(15) static initial (1,2,3,4,5,6,7,8,9,10);
declare (n,RMS) Dec Float(15);
n = hbound(A,1);
RMS = sqrt(sum(A**2)/n);
put Skip Data(rms);
End;
Output:
RMS= 6.20483682299543E+0000;

## PostScript

/findrms{
/x exch def
/sum 0 def
/i 0 def
x length 0 eq{}
{
x length{
/sum x i get 2 exp sum add def
}repeat
/sum sum x length div sqrt def
}ifelse
sum ==
}def

[1 2 3 4 5 6 7 8 9 10] findrms

Output:
6.20483685

Library: initlib
[1 10] 1 range dup 0 {dup * +} fold exch length div sqrt


## Potion

rms = (series) :
total = 0.0
series each (x): total += x * x.
total /= series length
total sqrt
.

rms((1, 2, 3, 4, 5, 6, 7, 8, 9, 10)) print

## Powerbuilder

long ll_x, ll_y, ll_product
decimal ld_rms

ll_x = 1
ll_y = 10
DO WHILE ll_x <= ll_y
ll_product += ll_x * ll_x
ll_x ++
LOOP
ld_rms = Sqrt(ll_product / ll_y)

//ld_rms value is 6.20483682299542849

function get-rms([float[]]$nums){$sqsum=$nums | foreach-object {$_*$_} | measure-object -sum | select-object -expand Sum return [math]::sqrt($sqsum/$nums.count) } get-rms @(1..10)  ## Processing void setup() { float[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; print(rms(numbers)); } float rms(float[] nums) { float mean = 0; for (float n : nums) { mean += sq(n); } mean = sqrt(mean / nums.length); return mean; } Output: 6.204837 ## Prolog Works with: GNU Prolog :- initialization(main). rms(Xs, Y) :- sum_of_squares(Xs, 0, Sum), length(Xs, N), Y is sqrt(Sum / N). sum_of_squares([], Sum, Sum). sum_of_squares([X|Xs], A, Sum) :- A1 is A + X * X, sum_of_squares(Xs, A1, Sum). main :- bagof(X, between(1, 10, X), Xs), rms(Xs, Y), format('The root-mean-square of 1..10 is ~f\n', [Y]).  Output: The root-mean-square of 1..10 is 6.204837  ## PureBasic NewList MyList() ; To hold a unknown amount of numbers to calculate If OpenConsole() Define.d result Define i, sum_of_squares ;Populate a random amounts of numbers to calculate For i=0 To (Random(45)+5) ; max elements is unknown to the program AddElement(MyList()) MyList()=Random(15) ; Put in a random number Next Print("Averages/Root mean square"+#CRLF$+"of : ")

; Calculate square of each element, print each & add them together
ForEach MyList()
Print(Str(MyList())+" ")             ; Present to our user
sum_of_squares+MyList()*MyList()     ; Sum the squares, e.g
Next

;Present the result
result=Sqr(sum_of_squares/ListSize(MyList()))
PrintN(#CRLF$+"= "+StrD(result)) PrintN("Press ENTER to exit"): Input() CloseConsole() EndIf ## Python Works with: Python version 3 >>> from math import sqrt >>> def qmean(num): return sqrt(sum(n*n for n in num)/len(num)) >>> qmean(range(1,11)) 6.2048368229954285  Note that function range in Python includes the first limit of 1, excludes the second limit of 11, and has a default increment of 1. The Python 2 version of this is nearly identical, except you must cast the sum to a float to get float division instead of integer division; or better, do a from __future__ import division, which works on Python 2.2+ as well as Python 3, and makes division work consistently like it does in Python 3. Alternatively in terms of reduce: from functools import (reduce) from math import (sqrt) # rootMeanSquare :: [Num] -> Float def rootMeanSquare(xs): return sqrt(reduce(lambda a, x: a + x * x, xs, 0) / len(xs)) print( rootMeanSquare([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) )  Output: 6.2048368229954285 ## Qi (define rms R -> (sqrt (/ (APPLY + (MAPCAR * R R)) (length R)))) ## Quackery Using the Quackery big number rational arithmetic library bigrat.qky. [$ "bigrat.qky" loadfile ] now!

[ [] swap
witheach
[ unpack 2dup v*
join nested join ] ] is squareall (   [ --> [   )

[ dup size n->v rot
0 n->v rot
witheach
[ unpack v+ ]
2swap v/ ]               is arithmean (   [ --> n/d )

[ dip
[ squareall arithmean ]
vsqrt drop ]             is rms       ( [ n --> n/d )

say "The RMS of the integers 1 to 10, to 80 decimal places with rounding." cr
say "(Checked on Wolfram Alpha. The final digit is correctly rounded up.)" cr cr

' [ [ 1 1 ] [ 2 1 ] [ 3 1 ] [ 4 1 ] [  5 1 ]
[ 6 1 ] [ 7 1 ] [ 8 1 ] [ 9 1 ] [ 10 1 ] ]

( ^^^ the integers 1 to 10 represented as a nest of nested rational numbers )

80 rms
80 point$echo$
Output:
The RMS of the integers 1 to 10, to 80 decimal places with rounding.
(Checked on Wolfram Alpha. The final digit is correctly rounded up.)

6.20483682299542829806662097772473784992796529536414069376132632095482141678247123

## R

The following function works for any vector x:

RMS <- function(x, na.rm = F) sqrt(mean(x^2, na.rm = na.rm))

RMS(1:10)
#  6.204837

RMS(c(NA, 1:10))
#  NA

RMS(c(NA, 1:10), na.rm = T)
#  6.204837

## Racket

#lang racket
(define (rms nums)
(sqrt (/ (for/sum ([n nums]) (* n n)) (length nums))))


## Raku

(formerly Perl 6)

sub rms(*@nums) { sqrt ([+] @nums X** 2) / @nums }

say rms 1..10;


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

sub rms { sqrt @_ R/ [+] @_ X** 2 }


## REXX

REXX has no built-in   sqrt   function, so a RYO version is included here.

This particular   sqrt   function was programmed for speed, as it has two critical components:

•   the initial guess (for the square root)
•   the number of (increasing) decimal digits used during the computations

The   sqrt   code was optimized to use the minimum amount of digits (precision) for each iteration of the
calculation as well as a reasonable attempt at providing a first-guess square root by essentially halving
the number using logarithmic (base ten) arithmetic.

/*REXX program computes and displays the  root mean square (RMS)  of a number sequence. */
parse arg nums digs show .                       /*obtain the optional arguments from CL*/
if nums==''  |  nums==","  then nums=10          /*Not specified?  Then use the default.*/
if digs==''  |  digs==","  then digs=50          /* "      "         "   "   "     "    */
if show==''  |  show==","  then show=10          /* "      "         "   "   "     "    */
numeric digits digs                              /*uses  DIGS  decimal digits for calc. */
$=0; do j=1 for nums /*process each of the N integers. */$=$+ j**2 /*sum the squares of the integers. */ end /*j*/ /* [↓] displays SHOW decimal digits.*/ rms=format( sqrt($/nums), , show ) / 1           /*divide by N, then calculate the SQRT.*/
say 'root mean square for 1──►'nums  "is: "  rms /*display the  root mean square (RMS). */
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
sqrt:  procedure; parse arg x;  if x=0  then return 0;  d=digits();  numeric digits;  m.=9
numeric form;  parse value format(x,2,1,,0) 'E0'  with  g 'E' _ .;  g=g *.5'e'_ % 2
h=d+6;    do j=0  while h>9;       m.j=h;                h=h%2+1;        end  /*j*/
do k=j+5  to 0  by -1;   numeric digits m.k;   g=(g+x/g)*.5;   end  /*k*/
return g


output   when using the default inputs:

root mean square for 1──►10 is:  6.204836823


## Ring

nums = [1,2,3,4,5,6,7,8,9,10]
sum = 0
decimals(5)
see "Average = " + average(nums) + nl

func average number
for i = 1 to len(number)
sum = sum + pow(number[i],2)
next
x = sqrt(sum / len(number))
return x

## RPL

≪ LIST→ → n
≪ 0 1 n START SWAP SQ + NEXT
n / √
≫ ≫ 'RMS' STO

{ 1 2 3 4 5 6 7 8 9 10 } RMS

Output:
1: 6.204836823

Works with: HP version 48G
≪ DUP ≪ SQ + ≫ STREAM SWAP SIZE / √
≫ 'RMS' STO


## Ruby

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

class Range
end
end



and a non object-oriented solution:

def rms(seq)
Math.sqrt(seq.sum{|x| x*x}.fdiv(seq.size) )
end
puts rms (1..10)   # => 6.2048368229954285


## Run BASIC

valueList$= "1 2 3 4 5 6 7 8 9 10" while word$(valueList$,i +1) <> "" ' grab values from list thisValue = val(word$(valueList$,i +1)) ' turn values into numbers sumSquares = sumSquares + thisValue ^ 2 ' sum up the squares i = i +1 ' wend print "List of Values:";valueList$;" containing ";i;" values"
print "Root Mean Square =";(sumSquares/i)^0.5
Output:

List of Values:1 2 3 4 5 6 7 8 9 10 containing 10 values Root Mean Square =6.20483682

## Rust

fn root_mean_square(vec: Vec<i32>) -> f32 {
let sum_squares = vec.iter().fold(0, |acc, &x| acc + x.pow(2));
return ((sum_squares as f32)/(vec.len() as f32)).sqrt();
}

fn main() {
let vec = (1..11).collect();
println!("The root mean square is: {}", root_mean_square(vec));
}

Output:
The root mean square is: 6.204837


## S-lang

Many of math operations in S-Lang are 'vectorized', that is, given an array, they apply themselves to each element. In this case, that means no array_map() function needed. Also, "range arrays" have a built-in syntax.

define rms(arr)
{
return sqrt(sum(sqr(arr)) / length(arr));
}

print(rms([1:10]));

## Sather

class MAIN is
-- irrms stands for Integer Ranged RMS
irrms(i, f:INT):FLT
pre i <= f
is
sum ::= 0;
loop
sum := sum + i.upto!(f).pow(2);
end;
return (sum.flt / (f-i+1).flt).sqrt;
end;

main is
#OUT + irrms(1, 10) + "\n";
end;
end;

## S-BASIC

var n, sqsum, sqmean, rms = real
sqsum = 0
for n = 1 to 10 do
sqsum = sqsum + (n * n)
next n
sqmean = sqsum / n
rms = sqr(sqmean)
print "RMS of numbers from 1 to 10 = ";rms

end

Output:
RMS of numbers from 1 to 10 =  6.20484


## Scala

def rms(nums: Seq[Int]) = math.sqrt(nums.map(math.pow(_, 2)).sum / nums.size)
println(rms(1 to 10))

Output:
6.2048368229954285

## Scheme

(define (rms nums)
(sqrt (/ (apply + (map * nums nums))
(length nums))))

(rms '(1 2 3 4 5 6 7 8 9 10))

Output:
6.20483682299543

$include "seed7_05.s7i"; include "float.s7i"; include "math.s7i"; const array float: numbers is [] (1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0); const func float: rms (in array float: numbers) is func result var float: rms is 0.0; local var float: number is 0.0; var float: sum is 0.0; begin for number range numbers do sum +:= number ** 2; end for; rms := sqrt(sum / flt(length(numbers))); end func; const proc: main is func begin writeln(rms(numbers) digits 7); end func; ## Shen Works with: shen-scheme version 0.17 (declare scm.sqrt [number --> number]) (tc +) (define mean { (list number) --> number } Xs -> (/ (sum Xs) (length Xs))) (define square { number --> number } X -> (* X X)) (define rms { (list number) --> number } Xs -> (scm.sqrt (mean (map (function square) Xs)))) (define iota-h { number --> number --> (list number) } X X -> [X] X Lim -> (cons X (iota-h (+ X 1) Lim))) (define iota { number --> (list number) } Lim -> (iota-h 1 Lim)) (output "~A~%" (rms (iota 10)))  ## Sidef func rms(a) { sqrt(a.map{.**2}.sum / a.len) } say rms(1..10)  Using hyper operators, we can write it as: func rms(a) { a »**» 2 «+» / a.len -> sqrt }  Output: 6.20483682299542829806662097772473784992796529536 ## Smalltalk (((1 to: 10) inject: 0 into: [ :s :n | n*n + s ]) / 10) sqrt.  ## SNOBOL4 Works with: Macro Spitbol Works with: CSnobol There is no built-in sqrt( ) function in Snobol4+.  define('rms(a)i,ssq') :(rms_end) rms i = i + 1; ssq = ssq + (a<i> * a<i>) :s(rms) rms = sqrt(1.0 * ssq / prototype(a)) :(return) rms_end * # Fill array, test and display str = '1 2 3 4 5 6 7 8 9 10'; a = array(10) loop i = i + 1; str len(p) span('0123456789') . a<i> @p :s(loop) output = str ' -> ' rms(a) end Output: 1 2 3 4 5 6 7 8 9 10 -> 6.20483682 ## SparForte As a structured script. #!/usr/local/bin/spar pragma annotate( summary, "calcrms" ) @( description, "Compute the Root mean square of the numbers 1..10." ) @( description, "The root mean square is also known by its initial RMS (or rms), and as the" ) @( description, "quadratic mean. The RMS is calculated as the mean of the squares of the" ) @( description, "numbers, square-rooted" ) @( see_also, "http://rosettacode.org/wiki/Averages/Root_mean_square" ) @( author, "Ken O. Burtch" ); pragma license( unrestricted ); pragma restriction( no_external_commands ); procedure calcrms is type float_arr is array(1..10) of float; list : constant float_arr := (1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0); total: float := 0.0; rms : float; begin for p in arrays.first(list)..arrays.last(list) loop total := @ + list(p)**2; end loop; rms := numerics.sqrt( total / float(arrays.length(list))); ? rms; end calcrms;  ## Standard ML fun rms(v: real vector) = let val v' = Vector.map (fn x => x*x) v val sum = Vector.foldl op+ 0.0 v' in Math.sqrt( sum/real(Vector.length(v')) ) end; rms(Vector.tabulate(10, fn n => real(n+1)));  Output: val it = 6.204836823 : real ## Stata Compute the RMS of a variable and return the result in r(rms). program rms, rclass syntax varname(numeric) [if] [in] tempvar x gen x'=varlist'^2 if' in' qui sum x' if' in' return scalar rms=sqrt(r(mean)) end  Example clear set obs 20 gen x=rnormal() rms x di r(rms) 1.0394189 rms x if x>0 di r(rms) .7423647 ## Swift extension Collection where Element: FloatingPoint { @inlinable public func rms() -> Element { return (lazy.map({$0 * $0 }).reduce(0, +) / Element(count)).squareRoot() } } print("RMS of 1...10: \((1...10).map(Double.init).rms())") Output: RMS of 1...10: 6.2048368229954285 ## Tcl Works with: Tcl version 8.5 proc qmean list { set sum 0.0 foreach value$list { set sum [expr {$sum +$value**2}] }
return [expr { sqrt($sum / [llength$list]) }]
}

puts "RMS(1..10) = [qmean {1 2 3 4 5 6 7 8 9 10}]"
Output:
RMS(1..10) = 6.2048368229954285


## Ursala

using the mean function among others from the flo library

#import nat
#import flo

#cast %e

rms = sqrt mean sqr* float* nrange(1,10)
Output:
6.204837e+00


## Vala

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

double rms(double[] list){
double sum_squares = 0;
double mean;

foreach ( double number in list){
sum_squares += (number * number);
}

mean = Math.sqrt(sum_squares / (double) list.length);

return mean;
} // end rms

public static void main(){
double[] list = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
double mean = rms(list);

stdout.printf("%s\n", mean.to_string());
}
Output:
6.2048368229954285


## VBA

Using Excel VBA

Private Function root_mean_square(s() As Variant) As Double
For i = 1 To UBound(s)
s(i) = s(i) ^ 2
Next i
root_mean_square = Sqr(WorksheetFunction.sum(s) / UBound(s))
End Function
Public Sub pythagorean_means()
Dim s() As Variant
s = [{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}]
Debug.Print root_mean_square(s)
End Sub

Without using Excel worksheetfunction:

Function rms(iLow As Integer, iHigh As Integer)
Dim i As Integer
If iLow > iHigh Then
i = iLow
iLow = iHigh
iHigh = i
End If
For i = iLow To iHigh
rms = rms + i ^ 2
Next i
rms = Sqr(rms / (iHigh - iLow + 1))
End Function

Sub foo()
Debug.Print rms(1, 10)
End Sub

Output:

 6.20483682299543


## V (Vlang)

import math

fn main() {
n := 10
mut sum := 0.0
for x := 1.0; x <= n; x++ {
sum += x * x
}
println(math.sqrt(sum / n))
}
Output:
6.2048368229954


## Wortel

@let {
; using a composition and a fork (like you would do in J)
rms1 ^(@sqrt @(@sum / #) *^@sq)

; using a function with a named argument
rms2 &a @sqrt ~/ #a @sum !*^@sq a

[[
!rms1 @to 10
!rms2 @to 10
]]
}
Output:
[6.2048368229954285 6.2048368229954285]

## Wren

var rms = ((1..10).reduce(0) { |acc, i| acc + i*i }/10).sqrt
System.print(rms)
Output:
6.2048368229954


## XLISP

(defun quadratic-mean (xs)
(sqrt
(/
(apply +
(mapcar (lambda (x) (expt x 2)) xs))
(length xs))))

; define a RANGE function, for testing purposes

(defun range (x y)
(if (< x y)
(cons x (range (+ x 1) y))))

(print (quadratic-mean (range 1 11)))
Output:
6.20483682299543

## XPL0

code CrLf=9;
code real RlOut=48;
int  N;
real S;
[S:= 0.0;
for N:= 1 to 10 do S:= S + sq(float(N));
RlOut(0, sqrt(S/10.0));
CrLf(0);
]
Output:
    6.20484


## Yacas

Sqrt(Add((1 .. 10)^2)/10)

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

## zkl

fcn rms(z){ ( z.reduce(fcn(p,n){ p + n*n },0.0) /z.len() ).sqrt() }

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

zkl: rms([1..10].walk())  //-->rms(T(1,2,3,4,5,6,7,8,9,10))
6.20484
`