Averages/Root mean square: Difference between revisions
Line 29: | Line 29: | ||
Using these equations:<br> |
Using these equations:<br> |
||
<math>\sum_{i=1}^n i^2 = \frac{n(n+1)(2n+1)}{6}</math> See [[wp:List of mathematical series]]<br><br> |
<math>\sum_{i=1}^n i^2 = \frac{n(n+1)(2n+1)}{6}</math> See [[wp:List of mathematical series]]<br><br> |
||
for <math>a<b</math> : <math>\sum_{i=a}^b i^2 = \sum_{i=1}^b i^2 - \sum_{i=1}^{a-1} i^2</math><br><br> |
for <math>0<a<b</math> : <math>\sum_{i=a}^b i^2 = \sum_{i=1}^b i^2 - \sum_{i=1}^{a-1} i^2</math><br><br> |
||
We can show that:<br> |
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> |
<math>\sum_{i=a}^b i^2 = \frac{b(b+1)(2b+1)-a(a-1)(2a-1)}{6}</math> |
Revision as of 02:47, 22 April 2010
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:
C.f. Averages/Pythagorean means
AutoHotkey
Using a loop
<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
Not using a loop
Using these equations:
See wp:List of mathematical series
for :
We can show that:
<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>
- 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 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
,
<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
<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>
- import nat
- import flo
- cast %e
rms = sqrt mean sqr* float* nrange(1,10) </lang> output:
6.204837e+00