Averages/Root mean square

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 initial 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}}.$

C.f. Averages/Pythagorean means

AutoHotkey

Method 1 uses a loop to build the sum: <lang autohotkey>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)

}</lang> Message box shows:

6.204837

Method 2 does not need 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<b$ : $\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}}$ <lang autohotkey>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))

}</lang> Message box shows:

6.204837

C

<lang c>#include <stdio.h>

1. include <math.h>

double rms(double *v, int n) {

 int i;
 double sum = 0.0;
 for(i=0; i < n;i++) sum += pow(v[i], 2);
 return sqrt(sum / n);

}

int main() {

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

}</lang>

Clojure

<lang clojure>(use '[clojure.contrib.math :only (sqrt)])

(defn rms [xs]

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

(count xs))))

(println (rms (range 1 11)))</lang>

Output:

6.2048368229954285

Factor

<lang factor>: root-mean-square ( seq -- mean )

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

( scratchpad ) 10 [1,b] root-mean-square .
6.204836822995428

Forth

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

Fortran

Assume $x$ stored in array x.

<lang Fortran>print *,sqrt( sum(x**2)/size(x) )</lang>

Haskell

Given the mean function defiend in Averages/Pythagorean means:

<lang haskell>main = print $ mean 2 [1 .. 10]</lang>

J

Solution: <lang j>rms=: (+/ % #)&.:*:</lang>

Example Usage: <lang j> rms >: i. 10 6.20484</lang>

JavaScript

Works with: JavaScript version 1.8

,

Works with: Firefox version 3.0

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

Logo

<lang logo>to rms :v

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

end

show rms iseq 1 10</lang>

Lua

<lang lua>function sumsq(a, ...) return a and a^2 + sumsq(...) or 0 end function rms(t) return (sumsq(unpack(t)) / #t)^.5 end

print(rms{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})</lang>

OCaml

<lang 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 *)</lang>

Oz

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

Output:

6.2048

Perl

<lang perl>sub rms {

       my $r = 0;
       $r += $_**2 for @_;
       return sqrt( $r/@_ );

}

my @ints = (1..10); print rms(@ints), "\n";</lang>

Perl 6

<lang perl6>sub rms(@nums) {

sqrt( ([+] (map * ** 2, @nums)) / @nums.elems );

}

say rms(1..10);</lang>

PL/I

<lang PL/I> declare A(10) fixed decimal static initial (1,2,3,4,5,6,7,8,9,10); n = hbound(A,1); RMS = sqrt(sum(A**2)/n); </lang>

PureBasic

When compiled for Windows x86 using PureBasic 4.41 , this program is only 6.50 kB.

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

Python

<lang Python>>>> from __future__ import division >>> from math import sqrt >>> def qmean(num): return sqrt(sum(n*n for n in num)/len(num))

>>> numbers = range(1,11) # 1..10 >>> qmean(numbers) 6.2048368229954285</lang>

R

<lang R> sqrt(sum((1:10)^2/10)) </lang> or generally, for x <lang R> x<-1:10 sqrt(sum((x)^2/length(x))) </lang>

Ruby

<lang ruby>class Array

 def quadratic_mean
   Math.sqrt( self.inject(0) {|s, y| s += y*y}.to_f / self.length )
 end

end

class Range

 def quadratic_mean
   self.to_a.quadratic_mean
 end

end

(1..10).quadratic_mean # => 6.20483682299543</lang>

Sather

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

Tcl

Works with: Tcl version 8.5

<lang tcl>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}]"</lang> Output:

RMS(1..10) = 6.2048368229954285

Ursala

using the mean function among others from the flo library <lang Ursala>

1. import nat
2. import flo

1. cast %e

rms = sqrt mean sqr* float* nrange(1,10) </lang> output:

6.204837e+00