Anonymous user
Averages/Root mean square: Difference between revisions
m
<lang> needs a language
(→{{header|AWK}}: compute RMS) |
m (<lang> needs a language) |
||
Line 9:
Cf. [[Averages/Pythagorean means]]
=={{header|Ada}}==
<lang Ada>with Ada.Float_Text_IO; use Ada.Float_Text_IO;
with Ada.Numerics.Elementary_Functions;
use Ada.Numerics.Elementary_Functions;
Line 29 ⟶ 28:
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:
<pre>
6.20484
</pre>
=={{header|ALGOL 68}}==
{{works with|ALGOL 68|Standard - no extensions to language used}}
{{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)}}
<lang algol68># Define the rms PROCedure & ABS OPerators for LONG... REAL #
Line 76 ⟶ 73:
=={{header|APL}}==
<lang APL> rms←{((+/⍵*2)÷⍴⍵)*0.5}
x←⍳10
rms x
6.204836823</lang>
=={{header|AutoHotkey}}==
Line 186 ⟶ 181:
}
}</lang>
An alternative method demonstrating the more functional style introduced by LINQ and lambda expressions in C# 3.
{{works with|C sharp|C#|3}}
<lang csharp>using System;
using System.Collections.Generic;
Line 238 ⟶ 230:
(println (rms (range 1 11)))</lang>
Output:
<pre>
Line 274 ⟶ 265:
</pre>
=={{header|Delphi}}/{{header|Pascal}}==
<lang Delphi>program AveragesMeanSquare;
Line 299 ⟶ 290:
=={{header|E}}==
Using the same generic mean function as used in [[../Pythagorean means#E|pythagorean means]]:
<lang e>def makeMean(base, include, finish) {
return def mean(numbers) {
Line 324 ⟶ 313:
rms([1,2,3,4,5,6,7,8,9,10]).</lang>
Output:
<
=={{header|Euphoria}}==
Line 343 ⟶ 331:
constant s = {1,2,3,4,5,6,7,8,9,10}
? rms(s)</lang>
Output:
<pre>6.204836823</pre>
Line 349 ⟶ 336:
=={{header|F Sharp|F#}}==
Uses a lambda expression and function piping.
<lang Fsharp>let RMS (x:float list) : float = List.map (fun y -> y**2.0) x |> List.average |> System.Math.Sqrt
let res = RMS [1.0..10.0]</lang>
Answer (in F# Interactive window):
<pre>val res : float = 6.204836823</pre>
=={{header|Fantom}}==
<lang fantom>class Main
{
static Float averageRms (Float[] nums)
Line 376 ⟶ 358:
echo ("RMS Average of $a is: " + averageRms(a))
}
}</lang>
=={{header|Factor}}==
Line 399 ⟶ 380:
=={{header|Fortran}}==
Assume <math> x </math> stored in array x.
<lang Fortran>print *,sqrt( sum(x**2)/size(x) )</lang>
=={{header|Go}}==
<lang go>package main
Line 426 ⟶ 407:
: ((list.collect { it*it }.sum()) / list.size()) ** 0.5
}</lang>
Test:
<lang groovy>def list = 1..10
Line 434 ⟶ 414:
Q: ${Q}
"""</lang>
Output:
<pre>list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Line 441 ⟶ 420:
=={{header|Haskell}}==
Given the <code>mean</code> function defiend in [[Averages/Pythagorean means]]:
<lang haskell>main = print $ mean 2 [1 .. 10]</lang>
Line 479 ⟶ 457:
<lang j> rms 1 + i. 10
6.20484</lang>
<code>*:</code> means [http://jsoftware.com/help/dictionary/d112.htm square]
Line 488 ⟶ 464:
=={{header|Java}}==
<lang java>public class RMS {
double ms = 0;
for (int i = 0; i < nums.length; i++)
ms += nums[i] * nums[i];
ms /= nums.length;
return Math.sqrt(ms);
}
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 " + rms(nums));
}
}</lang>
Output:
<pre>The RMS of the numbers from 1 to 10 is 6.2048368229954285</pre>
Line 591 ⟶ 566:
=={{header|Objeck}}==
<lang objeck>bundle Default {
class Hello {
function : Main(args : String[]) ~ Nil {
Line 609 ⟶ 583:
}
}
}</lang>
=={{header|OCaml}}==
<lang ocaml>let rms a =
sqrt (Array.fold_left (fun s x -> s +. x*.x) 0.0 a /.
Line 634 ⟶ 606:
in
{Show {RMS {List.number 1 10 1}}}</lang>
Output:
<pre>
Line 655 ⟶ 626:
RMS_first(10)</lang>
Asymptotically this is n/sqrt(3).
=={{header|Perl}}==
Line 678 ⟶ 646:
=={{header|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>
=={{header|PicoLisp}}==
Line 701 ⟶ 667:
=={{header|PostScript}}==
<lang postscript>/findrms{
/x exch def
/sum 0 def
Line 717 ⟶ 682:
}def
[1 2 3 4 5 6 7 8 9 10] findrms</lang>
Output:
<
6.20483685
</
{{libheader|initlib}}
<lang postscript>[1 10] 1 range dup 0 {dup * +} fold exch length div sqrt</lang>
=={{header|Powerbuilder}}==
<lang powerbuilder>long ll_x, ll_y, ll_product
decimal ld_rms
Line 744 ⟶ 705:
=={{header|PowerShell}}==
<lang PowerShell>function get-rms([float[]]$nums){
$sqsum=$nums | foreach-object { $_*$_} | measure-object -sum | select-object -expand Sum
Line 783 ⟶ 743:
=={{header|Python}}==
{{works with|Python|3}}
<lang Python>>>> from math import sqrt
>>> def qmean(num):
Line 795 ⟶ 754:
=={{header|Qi}}==
<lang qi>(define rms
R -> (sqrt (/ (APPLY + (MAPCAR * R R)) (length R))))</lang>
=={{header|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>
=={{header|REXX}}==
REXX has no built-in SQRT, so a simple version is included here.
<lang rexx>/*REXX program to compute root mean square. */
parse arg n . /*get the argument (maybe). */
Line 849 ⟶ 798:
numeric digits d /*restore the original precision.*/
return g/1 /*normalize to old precision. */</lang>
Output:
<pre>
root mean square for 1-->10 is 6.2048368229954282980666209777247378499279652953641
</pre>
Line 896 ⟶ 844:
=={{header|Scala}}==
<lang scala>def rms(nums: Seq[Int]) = math.sqrt(nums.map(math.pow(_, 2)).sum / nums.size)
println(rms(1 to 10))</lang>
=={{header|Scheme}}==
Line 908 ⟶ 853:
(rms '(1 2 3 4 5 6 7 8 9 10))</lang>
Output:
<
=={{header|Seed7}}==
Line 938 ⟶ 882:
=={{header|Smalltalk}}==
<lang smalltalk>(((1 to: 10) inject: 0 into: [ :s :n | n*n + s ]) / 10) sqrt.</lang>
=={{header|SNOBOL4}}==
{{works with|Macro Spitbol}}
{{works with|CSnobol}}
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<i> * a<i>) :s(rms)
Line 959 ⟶ 898:
output = str ' -> ' rms(a)
end</lang>
Output:
<pre>1 2 3 4 5 6 7 8 9 10 -> 6.20483682</pre>
Line 979 ⟶ 917:
=={{header|Ursala}}==
using the <code>mean</code> function among others from the <code>flo</code> library
<lang Ursala>#import nat
#import flo
#cast %e
rms = sqrt mean sqr* float* nrange(1,10)</lang>
output:
<pre>
Line 994 ⟶ 930:
=={{header|Vala}}==
Valac probably needs to have the flag "-X -lm" added to include the C Math library.
<lang vala>double rms(double[] list){
double sum_squares = 0;
double mean;
Line 1,013 ⟶ 948:
stdout.printf("%s\n", mean.to_string());
}</lang>
Output:
<pre>
| |||