Averages/Root mean square: Difference between revisions
(two versions in Pari/GP) |
(→{{header|PARI/GP}}: add asymptotics) |
||
Line 431:
RMS_first(10)</lang>
Asymptotically this is n/sqrt(3).
=={{header|Perl}}==
|
Revision as of 04:43, 1 November 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
Ada
<lang Ada> with Ada.Float_Text_IO; use Ada.Float_Text_IO; with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions; 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; </lang> Output:
6.20484
ALGOL 68
<lang algol68># 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))
)</lang> Output:
crude rms(one to ten): +6.20483682299543e +0 rms(one to ten): +6.20483682299543e +0
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
Avoiding 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>
C#
<lang csharp>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); } }
}</lang>
An alternative method demonstrating the more functional style introduced by LINQ and lambda expressions in C# 3.
<lang csharp>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((double)x.Sum(n => n * n) / x.Count()); } }
}</lang>
C++
<lang C++>#include <iostream>
- include <vector>
- include <algorithm>
- include <cmath>
- include <numeric>
int toSquare( int a ) {
return a * a ;
}
int main( ) {
std::vector<int> numbers ; for ( int i = 1 ; i < 11 ; i++ ) numbers.push_back( i ) ; std::transform( numbers.begin( ) , numbers.end( ) , numbers.begin( ) , toSquare ) ; double meansquare = sqrt ( ( std::accumulate( numbers.begin( ) , numbers.end( ) , 0 ))/10.0 ); std::cout << "The quadratic mean of the numbers 1 .. 10 is " << meansquare << " !\n" ; return 0 ;
}</lang> Output:
The quadratic mean of the numbers 1 .. 10 is 6.20484 !
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
Common Lisp
<lang lisp>(defun rms (x)
(sqrt (/ (reduce #'+ (mapcar (lambda (xi) (expt xi 2)) x)) (length x))))
(rms (loop for i from 1 upto 10 collect i))</lang>
D
<lang d>import std.stdio, std.math, std.algorithm, std.range;
real rms(Td)(Td d) {
return sqrt(reduce!("a+b*b")(d) / cast(real)d.length);
}
void main() {
writefln("%.19f", rms(iota(1, 11)));
}</lang> Output:
6.2048368229954282979
Erlang
<lang erlang>rms(Nums) ->
math:sqrt(lists:foldl(fun(E,S) -> S+E*E end, 0, Nums) / length(Nums)).
rms([1,2,3,4,5,6,7,8,9,10]).</lang>
Output: <lang>6.2048368229954285</lang>
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>
HicEst
<lang HicEst>sum = 0 DO i = 1, 10
sum = sum + i^2
ENDDO WRITE(ClipBoard) "RMS(1..10) = ", (sum/10)^0.5 </lang> RMS(1..10) = 6.204836823
Icon and Unicon
Icon
<lang Icon>procedure main() every put(x := [], 1 to 10) writes("x := [ "); every writes(!x," "); write("]") write("Quadratic mean:",q := qmean!x) end</lang>
<lang Icon>procedure qmean(L[]) #: quadratic mean
local m if *L = 0 then fail every (m := 0.0) +:= !L^2 return sqrt(m / *L)
end</lang>
Unicon
This Icon solution works in Unicon.
J
Solution: <lang j>rms=: (+/ % #)&.:*:</lang>
Example Usage: <lang j> rms 1 + i. 10 6.20484</lang>
Java
<lang java>import java.lang.Math;
public class RMS {
public static double rms(double[] nums) { double ms = 0; for (int i=0; i<nums.length; i+=1) { ms += nums[i]*nums[i]; } ms /= nums.length; return Math.sqrt(ms); } 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.printf("The RMS of the numbers from 1 to 10 is %f.\n", rms(nums)); }
}</lang>
Output: <lang>The RMS of the array is 6.204837.</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>
Mathematica
<lang Mathematica>RootMeanSquare@Range[10]</lang>
MATLAB
<lang MATLAB>function rms = quadraticMean(list)
rms = sqrt(sum(list.^2)/numel(list));
end</lang> Solution: <lang MATLAB>>> quadraticMean((1:10))
ans =
6.204836822995429</lang>
Objeck
<lang 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(); } }
} </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
PARI/GP
General RMS calculation: <lang>RMS(v)={
sqrt(sum(i=1,#v,v[i]^2)/#v)
};
RMS(vector(10,i,i))</lang>
Specific functions for the first n positive integers: <lang>RMS_first(n)={
sqrt((n+1)*(2*n+1)/6)
};
RMS_first(10)</lang> Asymptotically this is n/sqrt(3).
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( ([+] @nums X** 2) / +@nums );
}
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>
PicoLisp
<lang 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 ) ) )</lang>
Output:
6.20484
PostScript
<lang> /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 /i i 1 add def }repeat /sum sum x length div sqrt def }ifelse sum == }def
[1 2 3 4 5 6 7 8 9 10] findrms </lang> Output: <lang> 6.20483685 </lang>
Powerbuilder
<lang>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</lang>
PowerShell
<lang PowerShell>1..360 | ForEach-Object { [math]::sin( [math]::PI * $_ / 180 ) } | ForEach-Object { $sum = 0; $count = 0 } { $sum += $_ * $_; $count += 1 } { [math]::sqrt( $sum / $count ) }</lang>
PureBasic
<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>
Scheme
<lang scheme>(define (rms nums)
(sqrt (/ (apply + (map (lambda (x) (* x x)) nums)) (length nums))))
(rms '(1 2 3 4 5 6 7 8 9 10))</lang>
Output: <lang>6.20483682299543</lang>
SNOBOL4
There is no built-in sqrt( ) function in Snobol4+.
<lang SNOBOL4> define('rms(a)i,ssq') :(rms_end) rms i = i + 1; ssq = ssq + (a * a) :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 @p :s(loop)
output = str ' -> ' rms(a)
end</lang>
Output:
1 2 3 4 5 6 7 8 9 10 -> 6.20483682
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
- Programming Tasks
- Solutions by Programming Task
- Ada
- ALGOL 68
- AutoHotkey
- C
- C sharp
- C++
- Clojure
- Common Lisp
- D
- Erlang
- Factor
- Forth
- Fortran
- Haskell
- HicEst
- Icon
- Unicon
- J
- Java
- JavaScript
- Logo
- Lua
- Mathematica
- MATLAB
- Objeck
- OCaml
- Oz
- PARI/GP
- Perl
- Perl 6
- PL/I
- PicoLisp
- PostScript
- Powerbuilder
- PowerShell
- PowerShell examples needing attention
- Examples needing attention
- PureBasic
- Python
- R
- Ruby
- Sather
- Scheme
- SNOBOL4
- Tcl
- Ursala