Rosetta Code

Averages/Root mean square: Difference between revisions

Page Discussion

Averages/Root mean square (view source)

Revision as of 10:23, 29 December 2023

25,308 bytes added ,  5 months ago
m
→‎{{header|Elena}}
(Restored lost visibility of formula, and corrected exaggerated disparity between relative sizes of formula and text)
imported>Arakov
 
(94 intermediate revisions by 47 users not shown)
Line 1:
{{task}}
 
;Task
{{task heading}}
 
Compute the   [[wp:Root mean square|Root mean square]]   of the numbers 1..10.
Line 14:
 
 
{{task heading|;See also}}
 
{{Related tasks/Statistical measures}}
 
<br><hr>
 
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">F qmean(num)
R sqrt(sum(num.map(n -> n * n)) / Float(num.len))
 
print(qmean(1..10))</syntaxhighlight>
{{out}}
<pre>
6.20484
</pre>
 
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang="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)
RealAdd(sum,x2,tmp)
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</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Root_mean_square.png Screenshot from Atari 8-bit computer]
<pre>
RMS of 1..10 is 6.20483663
</pre>
 
=={{header|Ada}}==
<langsyntaxhighlight Adalang="ada">with Ada.Float_Text_IO; use Ada.Float_Text_IO;
with Ada.Numerics.Elementary_Functions;
use Ada.Numerics.Elementary_Functions;
Line 40 ⟶ 103:
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;</langsyntaxhighlight>
{{out}}
<pre>
Line 50 ⟶ 113:
{{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)}}
<langsyntaxhighlight lang="algol68"># Define the rms PROCedure & ABS OPerators for LONG... REAL #
MODE RMSFIELD = #LONG...# REAL;
PROC (RMSFIELD)RMSFIELD rms field sqrt = #long...# sqrt;
Line 77 ⟶ 140:
print(("crude rms(one to ten): ", crude rms(one to ten), new line));
print(("rms(one to ten): ", rms(one to ten), new line))
)</langsyntaxhighlight>
{{out}}
<pre>
crude rms(one to ten): +6.20483682299543e +0
rms(one to ten): +6.20483682299543e +0
</pre>
=={{header|ALGOL-M}}==
Because ALGOL-M lacks a built-in square root function, we have to supply our own.
<syntaxhighlight lang="algol">
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</syntaxhighlight>
{{out}}
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).
<pre>
RMS OF WHOLE NUMBERS 1.0 THROUGH 10.0 = 6.20483683432
</pre>
 
=={{header|ALGOL W}}==
<langsyntaxhighlight lang="algolw">begin
% computes the root-mean-square of an array of numbers with %
% the specified lower bound (lb) and upper bound (ub) %
Line 105 ⟶ 212:
write( "rms of 1 .. 10: ", rms( testNumbers, 1, 10 ) );
 
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 112 ⟶ 219:
 
=={{header|APL}}==
<langsyntaxhighlight APLlang="apl"> rms←{((+/⍵*2)÷⍴⍵)*0.5}
x←⍳10
 
rms x
6.204836823</langsyntaxhighlight>
 
=={{header|AppleScript}}==
===Functional===
{{Trans|JavaScript}}( ES6 version )
<syntaxhighlight lang="applescript">--------------------- 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</syntaxhighlight>
{{Out}}
<pre>6.204836822995</pre>
----
 
===Straightforward===
<syntaxhighlight lang="applescript">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})</syntaxhighlight>
 
{{output}}
<syntaxhighlight lang="applescript">6.204836822995</syntaxhighlight>
===Integer range alternative===
{{Trans|AutoHotKey}} '''("Avoiding a loop" solution)'''
<syntaxhighlight lang="applescript">
-- 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)</syntaxhighlight>
 
{{output}}
<syntaxhighlight lang="applescript">6.204836822995</syntaxhighlight>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="rebol">rootMeanSquare: function [arr]->
sqrt (sum map arr 'i -> i^2) // size arr
 
print rootMeanSquare 1..10</syntaxhighlight>
 
{{out}}
 
<pre>6.204836822995428</pre>
 
=={{header|Astro}}==
<syntaxhighlight lang="python">sqrt(mean(x²))</syntaxhighlight>
 
=={{header|AutoHotkey}}==
===Using a loop===
<langsyntaxhighlight lang="autohotkey">MsgBox, % RMS(1, 10)
 
 
Line 130 ⟶ 336:
Sum += (a + A_Index - 1) ** 2
Return, Sqrt(Sum / n)
}</langsyntaxhighlight>
Message box shows:
<pre>
Line 141 ⟶ 347:
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>
<langsyntaxhighlight lang="autohotkey">MsgBox, % RMS(1, 10)
 
 
Line 148 ⟶ 354:
;---------------------------------------------------------------------------
Return, Sqrt((b*(b+1)*(2*b+1)-a*(a-1)*(2*a-1))/6/(b-a+1))
}</langsyntaxhighlight>
Message box shows:
<pre>
Line 155 ⟶ 361:
 
=={{header|AWK}}==
<langsyntaxhighlight lang="awk">#!/usr/bin/awk -f
# computes RMS of the 1st column of a data file
{
Line 165 ⟶ 371:
END {
print "RMS: ",sqrt(S/N);
}</langsyntaxhighlight>
 
=={{header|BASIC}}==
Line 172 ⟶ 378:
Note that this will work in [[Visual Basic]] and the Windows versions of [[PowerBASIC]] by simply wrapping the module-level code into the <code>MAIN</code> function, and changing <code>PRINT</code> to <code>MSGBOX</code>.
 
<langsyntaxhighlight lang="qbasic">DIM i(1 TO 10) AS DOUBLE, L0 AS LONG
FOR L0 = 1 TO 10
i(L0) = L0
Line 185 ⟶ 391:
tmp = UBOUND(what) - LBOUND(what) + 1
rms# = SQR(rt / tmp)
END FUNCTION</langsyntaxhighlight>
 
See also: [[#BBC BASIC|BBC BASIC]], [[#Liberty BASIC|Liberty BASIC]], [[#PureBasic|PureBasic]], [[#Run BASIC|Run BASIC]]
Line 191 ⟶ 397:
==={{header|Applesoft BASIC}}===
 
<langsyntaxhighlight ApplesoftBasiclang="applesoftbasic"> 10 N = 10
20 FOR I = 1 TO N
30 S = S + I * I
40 NEXT
50 X = SQR (S / N)
60 PRINT X</langsyntaxhighlight>
 
{{out}}
<pre>6.20483683</pre>
 
==={{header|BBCCraft BASICBasic}}===
<syntaxhighlight lang="basic">precision 8
<lang bbcbasic> DIM array(9)
 
let n = 10
 
for i = 1 to n
 
let s = s + i * i
 
next i
 
print sqrt(s / n)</syntaxhighlight>
{{out| Output}}<pre>6.20483682</pre>
 
==={{header|IS-BASIC}}===
<syntaxhighlight lang="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</syntaxhighlight>
 
==={{header|Sinclair ZX81 BASIC}}===
<syntaxhighlight lang="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</syntaxhighlight>
{{out}}
<pre>6.2048368</pre>
 
==={{header|BBC BASIC}}===
<syntaxhighlight lang="bbcbasic"> DIM array(9)
array() = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Line 208 ⟶ 450:
END
DEF FNrms(a()) = MOD(a()) / SQR(DIM(a(),1)+1)</langsyntaxhighlight>
 
=={{header|BQN}}==
RMS is a tacit function which computes root mean square.
<syntaxhighlight lang="bqn">RMS ← √+´∘ט÷≠
 
RMS 1+↕10</syntaxhighlight>
<syntaxhighlight lang="text">6.2048368229954285</syntaxhighlight>
 
[https://mlochbaum.github.io/BQN/try.html#code=Uk1TIOKGkCDiiJorwrTiiJjDl8ucw7fiiaAKClJNUyAxK+KGlTEw Try It!]
 
Another solution is to take the arithmetic mean <code>+´÷≠</code> under the square (<code>ט</code>) function. Under (<code>⌾</code>) squares the arguments, then applies the mean, then inverts the square function.
<syntaxhighlight lang="bqn">RMS ← (+´÷≠)⌾(ט)</syntaxhighlight>
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <math.h>
 
Line 228 ⟶ 482:
printf("%f\n", rms(v, sizeof(v)/sizeof(double)));
return 0;
}</langsyntaxhighlight>
 
=={{header|C sharp|C#}}==
<langsyntaxhighlight lang="csharp">using System;
 
namespace rms
Line 253 ⟶ 507:
}
}
}</langsyntaxhighlight>
An alternative method demonstrating the more functional style introduced by LINQ and lambda expressions in C# 3.
{{works with|C sharp|C#|3}}
<langsyntaxhighlight lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
Line 271 ⟶ 525:
private static double rootMeanSquare(IEnumerable<int> x)
{
return Math.Sqrt((double)x.SumAverage(ni => n(double)i * n) / x.Count(i));
}
}
}</langsyntaxhighlight>
 
=={{header|C++}}==
<langsyntaxhighlight Cpplang="cpp">#include <iostream>
#include <vector>
#include <cmath>
Line 289 ⟶ 543:
std::cout << "The quadratic mean of the numbers 1 .. " << numbers.size() << " is " << meansquare << " !\n" ;
return 0 ;
}</langsyntaxhighlight>
{{out}}
<pre>
Line 296 ⟶ 550:
 
=={{header|Clojure}}==
<syntaxhighlight lang="clojure">
<lang clojure>(use '[clojure.contrib.math :only (sqrt)])
 
(defn rms [xs]
(Math/sqrt (/ (reduce + (map #(* % %) xs))
(count xs))))
 
(println (rms (range 1 11)))</langsyntaxhighlight>
{{out}}
<pre>
Line 310 ⟶ 563:
=={{header|COBOL}}==
Could be written more succinctly, with an inline loop and more <tt>COMPUTE</tt> statements; but that wouldn't be very COBOLic.
<langsyntaxhighlight lang="cobol">IDENTIFICATION DIVISION.
PROGRAM-ID. QUADRATIC-MEAN-PROGRAM.
DATA DIVISION.
Line 330 ⟶ 583:
ADD 1 TO N.
MULTIPLY N BY N GIVING N-SQUARED.
ADD N-SQUARED TO RUNNING-TOTAL.</langsyntaxhighlight>
{{out}}
<pre>6.204836822995428</pre>
Line 336 ⟶ 589:
=={{header|CoffeeScript}}==
{{trans|JavaScript}}
<langsyntaxhighlight lang="coffeescript"> root_mean_square = (ary) ->
sum_of_squares = ary.reduce ((s,x) -> s + x*x), 0
return Math.sqrt(sum_of_squares / ary.length)
alert root_mean_square([1..10])</langsyntaxhighlight>
 
=={{header|Common Lisp}}==
<langsyntaxhighlight lang="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))))</langsyntaxhighlight>
 
Here's a non-iterative solution.
 
<langsyntaxhighlight lang="lisp">
(defun root-mean-square (numbers)
"Takes a list of numbers, returns their quadratic mean."
Line 359 ⟶ 612:
 
(root-mean-square (loop for i from 1 to 10 collect i))
</syntaxhighlight>
</lang>
 
=={{header|Crystal}}==
{{trans|Ruby}}
<syntaxhighlight lang="ruby">def rms(seq)
Math.sqrt(seq.sum { |x| x*x } / seq.size)
end
 
puts rms (1..10).to_a</syntaxhighlight>
 
{{out}}
<pre>6.2048368229954285</pre>
 
=={{header|D}}==
<langsyntaxhighlight lang="d">import std.stdio, std.math, std.algorithm, std.range;
 
real rms(R)(R d) pure {
Line 370 ⟶ 634:
void main() {
writefln("%.19f", iota(1, 11).rms);
}</langsyntaxhighlight>
{{out}}
<pre>
Line 377 ⟶ 641:
 
=={{header|Delphi}}/{{header|Pascal}}==
<langsyntaxhighlight Delphilang="delphi">program AveragesMeanSquare;
 
{$APPTYPE CONSOLE}
Line 398 ⟶ 662:
Writeln(MeanSquare(TDoubleDynArray.Create()));
Writeln(MeanSquare(TDoubleDynArray.Create(1,2,3,4,5,6,7,8,9,10)));
end.</langsyntaxhighlight>
 
=={{header|E}}==
Using the same generic mean function as used in [[../Pythagorean means#E|pythagorean means]]:
<langsyntaxhighlight lang="e">def makeMean(base, include, finish) {
return def mean(numbers) {
var count := 0
Line 414 ⟶ 678:
}
 
def RMS := makeMean(0, fn b,x { b+x**2 }, fn acc,n { (acc/n).sqrt() })</langsyntaxhighlight>
 
<langsyntaxhighlight lang="e">? RMS(1..10)
# value: 6.2048368229954285</langsyntaxhighlight>
 
=={{header|EasyLang}}==
{{trans|C}}
<syntaxhighlight lang=easylang>
func rms v[] .
for v in v[]
sum += v * v
.
return sqrt (sum / len v[])
.
v[] = [ 1 2 3 4 5 6 7 8 9 10 ]
print rms v[]
</syntaxhighlight>
 
=={{header|EchoLisp}}==
<langsyntaxhighlight lang="scheme">
(define (rms xs)
(sqrt (// (for/sum ((x xs)) (* x x)) (length xs))))
Line 426 ⟶ 703:
(rms (range 1 11))
→ 6.2048368229954285
</syntaxhighlight>
</lang>
 
=={{header|Elena}}==
{{trans|C#}}
ELENA 6.x :
<syntaxhighlight lang="elena">import extensions;
import system'routines;
import system'math;
extension op
{
get RootMeanSquare()
= (self.selectBy::(x => x * x).summarize(Real.new()) / self.Length).sqrt();
}
public program()
{
console.printLine(new Range(1, 10).RootMeanSquare)
}</syntaxhighlight>
{{out}}
<pre>
6.204836822995
</pre>
 
=={{header|Elixir}}==
<langsyntaxhighlight lang="elixir">
defmodule RC do
def root_mean_square(enum) do
Line 444 ⟶ 743:
 
IO.puts RC.root_mean_square(1..10)
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 451 ⟶ 750:
 
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(defun rms (nums)
<Lang lisp>
(defun rms (nums)
;; `/' returns a float only when given floats
(setq nums (mapcar 'float nums))
(sqrt (/ (apply '+ (mapcar (lambda (x) (* x x)) nums))
(float (length nums)))))
</lang>
 
(rms (number-sequence 1 10))</syntaxhighlight>
or, if using Emacs's Common Lisp library <code>cl-lib.el</code> to use <code>cl-map</code>:
<Lang lisp>
(defun rms (nums)
(setq nums (mapcar 'float nums))
(sqrt (/ (apply '+ (cl-map 'list '* nums nums))
(length nums))))
 
{{out}}
(rms (number-sequence 1 10))
</lang>
<pre>6.2048368229954285</pre>
 
=={{header|Erlang}}==
<langsyntaxhighlight 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]).</langsyntaxhighlight>
{{out}}
<pre>6.2048368229954285</pre>
 
=={{header|ERRE}}==
<syntaxhighlight lang="text">
PROGRAM ROOT_MEAN_SQUARE
BEGIN
Line 489 ⟶ 778:
PRINT("Root mean square is";X)
END PROGRAM
</syntaxhighlight>
</lang>
You can, obviously, generalize reading data from a DATA line or from a file.
 
=={{header|Euphoria}}==
<langsyntaxhighlight lang="euphoria">function rms(sequence s)
atom sum
if length(s) = 0 then
Line 506 ⟶ 795:
 
constant s = {1,2,3,4,5,6,7,8,9,10}
? rms(s)</langsyntaxhighlight>
{{out}}
<pre>6.204836823</pre>
 
=={{header|Excel}}==
===Cell reference expression===
If values are entered in the cells A1 to A10, the below expression will give the RMS value
<langsyntaxhighlight lang="excel">
=SQRT(SUMSQ($A1:$A10)/COUNT($A1:$A10))
</syntaxhighlight>
</lang>
 
The RMS of [1,10] is then : 6.204836823 ( Actual displayed value 6.204837)
 
===LAMBDA===
 
In Excel builds equipped with the LAMBDA function, we can also rework the cell reference expression above to define a custom function, binding a name like ROOTMEANSQR to it in the workBook Name Manager:
 
(See [https://www.microsoft.com/en-us/research/blog/lambda-the-ultimatae-excel-worksheet-function/ LAMBDA: The ultimate Excel worksheet function])
 
{{Works with|Office 365 betas 2021}}
 
<syntaxhighlight lang="lisp">ROOTMEANSQR
=LAMBDA(xs,
SQRT(SUMSQ(xs)/COUNT(xs))
)</syntaxhighlight>
 
For this test, we assume that the following generic lambda is also bound to the name ENUMFROMTO in the Name Manager:
 
<syntaxhighlight lang="lisp">ENUMFROMTO
=LAMBDA(a,
LAMBDA(z,
SEQUENCE(1 + z - a, 1, a, 1)
)
)</syntaxhighlight>
 
{{Out}}
{| class="wikitable"
|-
|||style="text-align:right; font-family:serif; font-style:italic; font-size:120%;"|fx
! colspan="2" style="text-align:left; vertical-align: bottom; font-family:Arial, Helvetica, sans-serif !important;"|=ROOTMEANSQR( ENUMFROMTO( 1 )( 10 ) )
|- style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff;"
|
| A
| B
|- style="text-align:right;"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 1
| style="text-align:right; font-weight:bold" |
| style="font-weight:bold" | [1..10]
|- style="text-align:right;"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 2
| style="text-align:right; font-weight:bold" | Root mean square
| style="background-color:#cbcefb;" | 6.2048368229954285
|}
 
=={{header|F Sharp|F#}}==
Uses a lambda expression and function piping.
<langsyntaxhighlight Fsharplang="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]</langsyntaxhighlight>
Answer (in F# Interactive window):
<pre>val res : float = 6.204836823</pre>
 
=={{header|Factor}}==
<syntaxhighlight lang="factor">: root-mean-square ( seq -- mean )
[ [ sq ] map-sum ] [ length ] bi / sqrt ;</syntaxhighlight>
 
( scratchpad ) 10 [1,b] root-mean-square .
6.204836822995428
 
=={{header|Fantom}}==
<langsyntaxhighlight lang="fantom">class Main
{
static Float averageRms (Float[] nums)
Line 542 ⟶ 880:
echo ("RMS Average of $a is: " + averageRms(a))
}
}</langsyntaxhighlight>
 
=={{header|Factor}}==
<lang factor>: root-mean-square ( seq -- mean )
[ [ sq ] map-sum ] [ length ] bi / sqrt ;</lang>
 
( scratchpad ) 10 [1,b] root-mean-square .
6.204836822995428
 
=={{header|Forth}}==
<langsyntaxhighlight lang="forth">: rms ( faddr len -- frms )
dup >r 0e
floats bounds do
Line 560 ⟶ 891:
 
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</langsyntaxhighlight>
 
=={{header|Fortran}}==
Assume <math> x </math> stored in array x.
<langsyntaxhighlight Fortranlang="fortran">print *,sqrt( sum(x**2)/size(x) )</langsyntaxhighlight>
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">
' FB 1.05.0 Win64
 
Line 588 ⟶ 919:
Print "Press any key to quit the program"
Sleep
</syntaxhighlight>
</lang>
 
{{out}}
Line 597 ⟶ 928:
=={{header|Futhark}}==
 
<syntaxhighlight lang="futhark">
<lang Futhark>
import "futlib/math"
 
fun main(as: [n]f64): f64 =
sqrt64f64.sqrt ((reduce (+) 0.0 (map (**2.0) as)) / f64(n))
</syntaxhighlight>
</lang>
 
=={{header|GEORGE}}==
<syntaxhighlight lang="george">
<lang GEORGE>
1, 10 rep (i)
i i | (v) ;
Line 613 ⟶ 946:
sqrt
print
</syntaxhighlight>
</lang>
<pre>
6.204836822995428
Line 619 ⟶ 952:
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 633 ⟶ 966:
}
fmt.Println(math.Sqrt(sum / n))
}</langsyntaxhighlight>
{{out}}
<pre>
Line 641 ⟶ 974:
=={{header|Groovy}}==
Solution:
<langsyntaxhighlight lang="groovy">def quadMean = { list ->
list == null \
? null \
Line 647 ⟶ 980:
? 0 \
: ((list.collect { it*it }.sum()) / list.size()) ** 0.5
}</langsyntaxhighlight>
Test:
<langsyntaxhighlight lang="groovy">def list = 1..10
def Q = quadMean(list)
println """
list: ${list}
Q: ${Q}
"""</langsyntaxhighlight>
{{out}}
<pre>list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Line 660 ⟶ 993:
 
=={{header|Haskell}}==
Given the <code>mean</code> function defienddefined in [[Averages/Pythagorean means]]:
<langsyntaxhighlight lang="haskell">main = print $ mean 2 [1 .. 10]</langsyntaxhighlight>
 
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/):
 
<syntaxhighlight lang="haskell">import Data.List (genericLength)
 
rootMeanSquare :: [Double] -> Double
rootMeanSquare = sqrt . (((/) . foldr ((+) . (^ 2)) 0) <*> genericLength)
 
main :: IO ()
main = print $ rootMeanSquare [1 .. 10]</syntaxhighlight>
{{Out}}
<pre>6.2048368229954285</pre>
 
=={{header|HicEst}}==
<langsyntaxhighlight HicEstlang="hicest">sum = 0
DO i = 1, 10
sum = sum + i^2
ENDDO
WRITE(ClipBoard) "RMS(1..10) = ", (sum/10)^0.5 </langsyntaxhighlight>
RMS(1..10) = 6.204836823
 
=={{header|Icon}} and {{header|Unicon}}==
<langsyntaxhighlight Iconlang="icon">procedure main()
every put(x := [], 1 to 10)
writes("x := [ "); every writes(!x," "); write("]")
write("Quadratic mean:",q := qmean!x)
end</langsyntaxhighlight>
 
 
<langsyntaxhighlight Iconlang="icon">procedure qmean(L[]) #: quadratic mean
local m
if *L = 0 then fail
every (m := 0.0) +:= !L^2
return sqrt(m / *L)
end</langsyntaxhighlight>
 
=={{header|Io}}==
<langsyntaxhighlight Iolang="io">rms := method (figs, (figs map(** 2) reduce(+) / figs size) sqrt)
 
rms( Range 1 to(10) asList ) println</langsyntaxhighlight>
 
=={{header|J}}==
'''Solution:'''
<langsyntaxhighlight lang="j">rms=: (+/ % #)&.:*:</langsyntaxhighlight>
 
'''Example Usage:'''
<langsyntaxhighlight lang="j"> rms 1 + i. 10
6.20484</langsyntaxhighlight>
<code>*:</code> means [http://jsoftware.com/help/dictionary/d112.htm square]
 
Line 705 ⟶ 1,050:
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">public class RMSRootMeanSquare {
 
public static double rms(double[] nums){
public static double rootMeanSquare(double... ms =nums) 0;{
fordouble (int isum = 0; i < nums.length0; i++)
for (double num ms += nums[i] *: nums[i];)
ms / sum += nums.lengthnum * num;
return Math.sqrt(mssum / 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 " + rmsrootMeanSquare(nums));
}
}</langsyntaxhighlight>
{{out}}
<pre>The RMS of the numbers from 1 to 10 is 6.2048368229954285</pre>
Line 726 ⟶ 1,071:
{{works with|JavaScript|1.8}}
{{works with|Firefox|3.0}}
<langsyntaxhighlight 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</langsyntaxhighlight>
 
 
===ES6===
 
<langsyntaxhighlight JavaScriptlang="javascript">(lst() => {
'use strict';
 
 
// rootMeanSquare :: [Num] -> Real
letconst rootMeanSquare = lstxs =>
Math.sqrt(
lstxs.reduce(
(a, x) => (a + x * x),
0
) / lstxs.length
);
 
 
return rootMeanSquare(lst[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 
// -> 6.2048368229954285
 
})();</syntaxhighlight>
})([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);</lang>
 
{{Out}}
Line 760 ⟶ 1,105:
=={{header|jq}}==
The following filter returns ''null'' if given an empty array:
<langsyntaxhighlight lang="jq">def rms: length as $length
| if $length == 0 then null
else map(. * .) | add | sqrt / $length
end ;</langsyntaxhighlight>With this definition, the following program would compute the rms of each array in a file or stream of numeric arrays:<syntaxhighlight lang ="jq">rms</langsyntaxhighlight>
 
=={{header|Julia}}==
There are a variety of ways to do this via built-in functions in Julia, given an array <code>A = [1:10]</code> of values. The formula can be implemented directly as:
<langsyntaxhighlight lang="julia">sqrt(sum(A.^2.) / length(A))</langsyntaxhighlight>
or shorter with using Statistics (and as spoken: root-mean-square)
<langsyntaxhighlight lang="julia">sqrt(mean(A.^2.))</langsyntaxhighlight>
or the implicit allocation of a new array by <code>A.^2.</code> can be avoided by using <code>sum</code> as a higher-order function: <langsyntaxhighlight lang="julia">sqrt(sum(x -> x*x, A) / length(A))</langsyntaxhighlight>
One can also use an explicit loop for near-C performance
<langsyntaxhighlight lang="julia">
function rms(A)
s = 0.0
Line 779 ⟶ 1,125:
return sqrt(s / length(A))
end
</syntaxhighlight>
</lang>
Potentially even better is to use the built-in <code>norm</code> function, which computes the square root of the sum of the squares of the entries of <code>A</code> in a way that avoids the possibility of spurious floating-point overflow (if the entries of <code>A</code> are so large that they may overflow if squared): <langsyntaxhighlight lang="julia">norm(A) / sqrt(length(A))</langsyntaxhighlight>
 
=={{header|K}}==
<syntaxhighlight lang="k">
<lang K>
rms:{_sqrt (+/x^2)%#x}
rms 1+!10
6.204837
</syntaxhighlight>
</lang>
 
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// 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)}")
}</syntaxhighlight>
 
{{out}}
<pre>
Quadratic mean of numbers 1 to 10 is 6.2048368229954285
</pre>
 
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{def rms
{lambda {:n}
{sqrt
{/ {+ {S.map {lambda {:i} {* :i :i}}
{S.serie 1 :n}}}
:n}}}}
-> rms
 
{rms 10}
-> 6.2048368229954285
</syntaxhighlight>
 
=={{header|Lasso}}==
<langsyntaxhighlight Lassolang="lasso">define rms(a::staticarray)::decimal => {
return math_sqrt((with n in #a sum #n*#n) / decimal(#a->size))
}
rms(generateSeries(1,10)->asStaticArray)</langsyntaxhighlight>
 
{{out}}
Line 799 ⟶ 1,177:
 
=={{header|Liberty BASIC}}==
<langsyntaxhighlight lang="lb">' [RC] Averages/Root mean square
 
SourceList$ ="1 2 3 4 5 6 7 8 9 10"
Line 824 ⟶ 1,202:
print "R.M.S. value is "; ( SumOfSquares /n)^0.5
 
end</langsyntaxhighlight>
 
=={{header|Logo}}==
<langsyntaxhighlight lang="logo">to rms :v
output sqrt quotient (apply "sum map [? * ?] :v) count :v
end
 
show rms iseq 1 10</langsyntaxhighlight>
 
=={{header|Lua}}==
<langsyntaxhighlight 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})</langsyntaxhighlight>
 
=={{header|Maple}}==
<langsyntaxhighlight Maplelang="maple">y := [ seq(1..10) ]:
RMS := proc( x )
return sqrt( Statistics:-Mean( x ^~ 2 ) );
end proc:
RMS( y );
</syntaxhighlight>
</lang>
{{out}}
<pre>6.20483682299543
Line 851 ⟶ 1,229:
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang Mathematica="mathematica">RootMeanSquare@Range[10]</langsyntaxhighlight>
The above will give the precise solution <math>\sqrt{\frac{77}{2}}</math>, to downgrade to 6.20484, use '<code>10.</code>' to imply asking for numeric solution, or append '<code>//N</code>' after the whole expression.
 
=={{header|MATLAB}}==
<langsyntaxhighlight MATLABlang="matlab">function rms = quadraticMean(list)
rms = sqrt(mean(list.^2));
end</langsyntaxhighlight>
Solution:
<langsyntaxhighlight MATLABlang="matlab">>> quadraticMean((1:10))
 
ans =
 
6.204836822995429</langsyntaxhighlight>
 
=={{header|Maxima}}==
<langsyntaxhighlight lang="maxima">L: makelist(i, i, 10)$
 
rms(L) := sqrt(lsum(x^2, x, L)/length(L))$
 
rms(L), numer; /* 6.204836822995429 */</langsyntaxhighlight>
 
=={{header|MAXScript}}==
<syntaxhighlight lang="maxscript">
<lang MAXScript>
fn RMS arr =
(
Line 879 ⟶ 1,258:
return (sqrt (sumSquared/arr.count as float))
)
</syntaxhighlight>
</lang>
Output:
<syntaxhighlight lang="maxscript">
<lang MAXScript>
rms #{1..10}
6.20484
</syntaxhighlight>
</lang>
 
=={{header|min}}==
{{works with|min|0.37.0}}
<syntaxhighlight lang="min">(((dup *) map sum) keep size / sqrt) ^rms
 
(1 2 3 4 5 6 7 8 9 10) rms puts!</syntaxhighlight>
{{out}}
<pre>6.204836822995428</pre>
 
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">0 П0 П1 С/П x^2 ИП0 x^2 ИП1 *
+ ИП1 1 + П1 / КвКор П0 БП
03</langsyntaxhighlight>
 
''Instruction:'' В/О С/П Number С/П Number ...
Line 897 ⟶ 1,284:
=={{header|Morfa}}==
{{trans|D}}
<langsyntaxhighlight lang="morfa">
import morfa.base;
import morfa.functional.base;
Line 912 ⟶ 1,299:
println(rms(1 .. 11));
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 919 ⟶ 1,306:
 
=={{header|Nemerle}}==
<langsyntaxhighlight Nemerlelang="nemerle">using System;
using System.Console;
using System.Math;
Line 935 ⟶ 1,322:
WriteLine("RMS of [1 .. 10]: {0:g6}", RMS($[1 .. 10]));
}
}</langsyntaxhighlight>
 
=={{header|NetRexx}}==
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
options replace format comments java crossref symbols nobinary
 
Line 953 ⟶ 1,340:
 
return
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 960 ⟶ 1,347:
 
=={{header|Nim}}==
<syntaxhighlight lang="nim">from math import sqrt, sum
<lang nim>import math
from sequtils import mapIt
 
proc qmean(num): float =
proc qmean(num: seq[float]): float =
for n in num:
result += nnum.mapIt(it *n 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])</langsyntaxhighlight>
{{out}}
<pre>6.2048368229954285e+00204836822995428</pre>
 
=={{header|Oberon-2}}==
Oxford Oberon-2
<langsyntaxhighlight lang="oberon2">
MODULE QM;
IMPORT ML := MathL, Out;
Line 998 ⟶ 1,385:
Out.String("Quadratic Mean: ");Out.LongReal(Rms(nums));Out.Ln
END QM.
</syntaxhighlight>
</lang>
{{out}}
<pre>
Quadratic Mean: 6.20483682300
</pre>
 
=={{header|Objeck}}==
<langsyntaxhighlight lang="objeck">bundle Default {
class Hello {
function : Main(args : String[]) ~ Nil {
Line 1,021 ⟶ 1,409:
}
}
}</langsyntaxhighlight>
 
=={{header|OCaml}}==
<langsyntaxhighlight lang="ocaml">let rms a =
sqrt (Array.fold_left (fun s x -> s +. x*.x) 0.0 a /.
float_of_int (Array.length a))
Line 1,030 ⟶ 1,418:
 
rms (Array.init 10 (fun i -> float_of_int (i+1))) ;;
(* 6.2048368229954285 *)</langsyntaxhighlight>
 
=={{header|Oforth}}==
 
<langsyntaxhighlight Oforthlang="oforth">10 seq map(#sq) sum 10.0 / sqrt .</langsyntaxhighlight>
 
{{out}}
Line 1,042 ⟶ 1,430:
 
=={{header|ooRexx}}==
<langsyntaxhighlight ooRexxlang="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)
Line 1,063 ⟶ 1,451:
return rxcalcsqrt(sum/numbers~items)
 
::requires rxmath LIBRARY</langsyntaxhighlight>
{{out}}
<pre>list = 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
Line 1,075 ⟶ 1,463:
 
=={{header|Oz}}==
<langsyntaxhighlight lang="oz">declare
fun {Square X} X*X end
 
Line 1,085 ⟶ 1,473:
end
in
{Show {RMS {List.number 1 10 1}}}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,093 ⟶ 1,481:
=={{header|PARI/GP}}==
General RMS calculation:
<langsyntaxhighlight lang="parigp">RMS(v)={
sqrt(sum(i=1,#v,v[i]^2)/#v)
};
 
RMS(vector(10,i,i))</langsyntaxhighlight>
 
Specific functions for the first ''n'' positive integers:
<langsyntaxhighlight lang="parigp">RMS_first(n)={
sqrt((n+1)*(2*n+1)/6)
};
 
RMS_first(10)</langsyntaxhighlight>
Asymptotically this is n/sqrt(3).
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">use v5.10.0;
sub rms
{
Line 1,116 ⟶ 1,504:
}
 
say rms(1..10);</langsyntaxhighlight>
 
=={{header|Perl 6}}==
{{works with|Rakudo|2015.12}}
<lang perl6>sub rms(*@nums) { sqrt [+](@nums X** 2) / @nums }
 
say rms 1..10;</lang>
 
Here's a slightly more concise version, albeit arguably less readable:
<lang perl6>sub rms { sqrt @_ R/ [+] @_ X** 2 }</lang>
 
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<lang Phix>function rms(sequence s)
<span style="color: #008080;">function</span> <span style="color: #000000;">rms</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
atom sqsum = 0
<span style="color: #004080;">atom</span> <span style="color: #000000;">sqsum</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
for i=1 to length(s) do
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
sqsum += power(s[i],2)
<span style="color: #000000;">sqsum</span> <span style="color: #0000FF;">+=</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
end for
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
return sqrt(sqsum/length(s))
<span style="color: #008080;">return</span> <span style="color: #7060A8;">sqrt</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sqsum</span><span style="color: #0000FF;">/</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">))</span>
end function
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
? rms({1,2,3,4,5,6,7,8,9,10})</lang>
<span style="color: #0000FF;">?</span><span style="color: #000000;">rms</span><span style="color: #0000FF;">({</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">,</span><span style="color: #000000;">8</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">})</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
6.204836823
</pre>
Alternative, same output<br>
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.
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">function</span> <span style="color: #000000;">rms</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">sqsum</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">power</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">}))</span>
<span style="color: #008080;">return</span> <span style="color: #7060A8;">sqrt</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sqsum</span><span style="color: #0000FF;">/</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">rms</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">))</span>
<span style="color: #000080;font-style:italic;">-- ?sqrt(sum(apply(true,power,{tagset(10),2}))/10) -- (ugh)</span>
<!--</syntaxhighlight>-->
 
=={{header|Phixmonti}}==
<syntaxhighlight lang="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</syntaxhighlight>
 
=={{header|PHP}}==
<langsyntaxhighlight PHPlang="php"><?php
// Created with PHP 7.0
 
Line 1,158 ⟶ 1,565:
 
echo rms(array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
</syntaxhighlight>
</lang>
{{out}}
<pre>
6.2048368229954
</pre>
 
=={{header|Picat}}==
{{trans|Prolog}}
{{works with|Picat}}
<syntaxhighlight lang="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).
</syntaxhighlight>
{{out}}
<pre>
The root-mean-square of 1..10 is 6.204837
</pre>
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="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)
Line 1,176 ⟶ 1,607:
(length Lst) )
T )
*Scl ) ) )</langsyntaxhighlight>
{{out}}
<pre>6.20484</pre>
 
=={{header|PL/I}}==
<langsyntaxhighlight PLlang="pl/Ii"> 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);
Line 1,187 ⟶ 1,618:
RMS = sqrt(sum(A**2)/n);
put Skip Data(rms);
End;</langsyntaxhighlight>
{{out}}
<pre>RMS= 6.20483682299543E+0000;</pre>
 
=={{header|PostScript}}==
<langsyntaxhighlight lang="postscript">/findrms{
/x exch def
/sum 0 def
Line 1,207 ⟶ 1,638:
}def
 
[1 2 3 4 5 6 7 8 9 10] findrms</langsyntaxhighlight>
{{out}}
<pre>
Line 1,213 ⟶ 1,644:
</pre>
{{libheader|initlib}}
<langsyntaxhighlight lang="postscript">[1 10] 1 range dup 0 {dup * +} fold exch length div sqrt</langsyntaxhighlight>
 
=={{header|Potion}}==
<syntaxhighlight lang="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</syntaxhighlight>
 
 
=={{header|Powerbuilder}}==
<langsyntaxhighlight lang="powerbuilder">long ll_x, ll_y, ll_product
decimal ld_rms
 
Line 1,227 ⟶ 1,669:
ld_rms = Sqrt(ll_product / ll_y)
 
//ld_rms value is 6.20483682299542849</langsyntaxhighlight>
 
=={{header|PowerShell}}==
<langsyntaxhighlight PowerShelllang="powershell">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) </langsyntaxhighlight>
 
=={{header|Processing}}==
<syntaxhighlight lang="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;
}</syntaxhighlight>
{{out}}
<pre>6.204837</pre>
 
=={{header|Prolog}}==
{{works with|GNU Prolog}}
<syntaxhighlight lang="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]).
</syntaxhighlight>
{{out}}
<pre>
The root-mean-square of 1..10 is 6.204837
</pre>
 
=={{header|PureBasic}}==
<langsyntaxhighlight PureBasiclang="purebasic">NewList MyList() ; To hold a unknown amount of numbers to calculate
 
If OpenConsole()
Line 1,264 ⟶ 1,749:
PrintN("Press ENTER to exit"): Input()
CloseConsole()
EndIf</langsyntaxhighlight>
 
=={{header|Python}}==
{{works with|Python|3}}
<langsyntaxhighlight Pythonlang="python">>>> from math import sqrt
>>> def qmean(num):
return sqrt(sum(n*n for n in num)/len(num))
 
>>> qmean(range(1,11))
6.2048368229954285</langsyntaxhighlight>
<small>Note that function [http://docs.python.org/release/3.2/library/functions.html#range range] in Python includes the first limit of 1, excludes the second limit of 11, and has a default increment of 1.</small>
 
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 <code>from __future__ import division</code>, 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''':
<syntaxhighlight lang="python">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])
)</syntaxhighlight>
{{Out}}
<pre>6.2048368229954285</pre>
 
=={{header|Qi}}==
<langsyntaxhighlight lang="qi">(define rms
R -> (sqrt (/ (APPLY + (MAPCAR * R R)) (length R))))</langsyntaxhighlight>
 
 
=={{header|Quackery}}==
 
Using the Quackery big number rational arithmetic library <code>bigrat.qky</code>.
 
<syntaxhighlight lang="quackery">[ $ "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$</syntaxhighlight>
 
{{out}}
 
<pre>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</pre>
 
=={{header|R}}==
 
We may calculate the answer directly using R's built-in <code>sqrt</code> and <code>mean</code> functions:
<lang R>sqrt(mean((1:10)^2))</lang>
The following function works for any vector x:
<langsyntaxhighlight Rlang="rsplus">RMS =<- function(x, na.rm = F) sqrt(mean(x^2, na.rm = na.rm)){
 
sqrt(mean(x^2))
RMS(1:10)
}</lang>
# [1] 6.204837
Usage:
 
<lang R>> RMS(1:10)
RMS(c(NA, 1:10))
[1] 6.204837 </lang>
# [1] NA
 
RMS(c(NA, 1:10), na.rm = T)
# [1] 6.204837</syntaxhighlight>
 
=={{header|Racket}}==
<syntaxhighlight lang="racket">
<lang Racket>
#lang racket
(define (rms nums)
(sqrt (/ (for/sum ([n nums]) (* n n)) (length nums))))
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
(formerly Perl 6)
 
<syntaxhighlight lang="raku" line>sub rms(*@nums) { sqrt ([+] @nums X** 2) / @nums }
 
say rms 1..10;</syntaxhighlight>
 
Here's a slightly more concise version, albeit arguably less readable:
<syntaxhighlight lang="raku" line>sub rms { sqrt @_ R/ [+] @_ X** 2 }</syntaxhighlight>
 
=={{header|REXX}}==
Line 1,308 ⟶ 1,863:
<br>calculation as well as a reasonable attempt at providing a first-guess square root by essentially halving
<br>the number using logarithmic (base ten) arithmetic.
<langsyntaxhighlight lang="rexx">/*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.*/
Line 1,326 ⟶ 1,881:
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</langsyntaxhighlight>
'''output''' &nbsp; when using the default inputs:
<pre>
Line 1,333 ⟶ 1,888:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
nums = [1,2,3,4,5,6,7,8,9,10]
sum = 0
Line 1,345 ⟶ 1,900:
x = sqrt(sum / len(number))
return x
</syntaxhighlight>
</lang>
 
=={{header|RPL}}==
≪ LIST→ → n
≪ 0 1 n '''START''' SWAP SQ + '''NEXT'''
n / √
≫ ≫ '<span style="color:blue">RMS</span>' STO
 
{ 1 2 3 4 5 6 7 8 9 10 } <span style="color:blue">RMS</span>
{{out}}
<pre>
1: 6.204836823
</pre>
{{works with|HP|48G}}
≪ DUP ≪ SQ + ≫ STREAM SWAP SIZE / √
≫ '<span style="color:blue">RMS</span>' STO
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">class Array
def quadratic_mean
Math.sqrt( self.inject(0.0) {|s, y| s + y*y} / self.length )
Line 1,360 ⟶ 1,930:
end
 
(1..10).quadratic_mean # => 6.2048368229954285</langsyntaxhighlight>
 
and a non object-oriented solution:
<langsyntaxhighlight lang="ruby">def rms(seq)
Math.sqrt(seq.inject(0.0) sum{|sum, x| sum + x*x} / .fdiv(seq.lengthsize) )
end
puts rms (1..10).to_a # => 6.2048368229954285</langsyntaxhighlight>
 
=={{header|Run BASIC}}==
<langsyntaxhighlight lang="runbasic">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
Line 1,376 ⟶ 1,946:
wend
print "List of Values:";valueList$;" containing ";i;" values"
print "Root Mean Square =";(sumSquares/i)^0.5</langsyntaxhighlight>
 
{{out}}
Line 1,383 ⟶ 1,953:
 
=={{header|Rust}}==
<langsyntaxhighlight lang="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();
Line 1,391 ⟶ 1,961:
let vec = (1..11).collect();
println!("The root mean square is: {}", root_mean_square(vec));
}</langsyntaxhighlight>
 
{{out}}
<pre>
The root mean square is: 6.204837
</pre>
 
 
=={{header|S-lang}}==
Line 1,403 ⟶ 1,974:
built-in syntax.
 
<langsyntaxhighlight Slang="s-lang">define rms(arr)
{
return sqrt(sum(sqr(arr)) / length(arr));
}
 
print(rms([1:10]));</langsyntaxhighlight>
 
=={{header|Sather}}==
<langsyntaxhighlight lang="sather">class MAIN is
-- irrms stands for Integer Ranged RMS
irrms(i, f:INT):FLT
Line 1,426 ⟶ 1,997:
#OUT + irrms(1, 10) + "\n";
end;
end;</langsyntaxhighlight>
 
=={{header|S-BASIC}}==
<syntaxhighlight lang="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
</syntaxhighlight>
{{out}}
<pre>
RMS of numbers from 1 to 10 = 6.20484
</pre>
 
=={{header|Scala}}==
<langsyntaxhighlight lang="scala">def rms(nums: Seq[Int]) = math.sqrt(nums.map(math.pow(_, 2)).sum / nums.size)
println(rms(1 to 10))</langsyntaxhighlight>
{{out}}
<pre>6.2048368229954285</pre>
 
=={{header|Scheme}}==
<langsyntaxhighlight lang="scheme">(define (rms nums)
(sqrt (/ (apply + (map * nums nums))
(length nums))))
 
(rms '(1 2 3 4 5 6 7 8 9 10))</langsyntaxhighlight>
{{out}}
<pre>6.20483682299543</pre>
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "float.s7i";
include "math.s7i";
Line 1,466 ⟶ 2,055:
begin
writeln(rms(numbers) digits 7);
end func;</langsyntaxhighlight>
 
=={{header|Shen}}==
{{works with|shen-scheme|0.17}}
<syntaxhighlight lang="shen">(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)))</syntaxhighlight>
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func rms(a) {
Math.sqrt(a.map{.**2}.sum / a.len);
}
 
say rms(1..10);</langsyntaxhighlight>
 
Using hyper operators, we can write it as:
<syntaxhighlight lang="ruby">func rms(a) { a »**» 2 «+» / a.len -> sqrt }</syntaxhighlight>
 
{{out}}
<pre>6.20483682299542829806662097772473784992820483682299542829806662097772473784992796529536</pre>
 
=={{header|Smalltalk}}==
<langsyntaxhighlight lang="smalltalk">(((1 to: 10) inject: 0 into: [ :s :n | n*n + s ]) / 10) sqrt.</langsyntaxhighlight>
 
=={{header|SNOBOL4}}==
Line 1,484 ⟶ 2,106:
{{works with|CSnobol}}
There is no built-in sqrt( ) function in Snobol4+.
<langsyntaxhighlight SNOBOL4lang="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)
Line 1,493 ⟶ 2,115:
loop i = i + 1; str len(p) span('0123456789') . a<i> @p :s(loop)
output = str ' -> ' rms(a)
end</langsyntaxhighlight>
{{out}}
<pre>1 2 3 4 5 6 7 8 9 10 -> 6.20483682</pre>
 
=={{header|SparForte}}==
As a structured script.
<syntaxhighlight lang="ada">#!/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;</syntaxhighlight>
 
=={{header|Standard ML}}==
<langsyntaxhighlight lang="sml">fun rms(v: real vector) =
let
val v' = Vector.map (fn x => x*x) v
Line 1,506 ⟶ 2,155:
end;
 
rms(Vector.tabulate(10, fn n => real(n+1)));</langsyntaxhighlight>
{{out}}
<pre>val it = 6.204836823 : real</pre>
 
=={{header|Stata}}==
Compute the RMS of a variable and return the result in r(rms).
 
<syntaxhighlight lang="stata">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</syntaxhighlight>
 
'''Example'''
 
<syntaxhighlight lang="stata">clear
set obs 20
gen x=rnormal()
 
rms x
di r(rms)
1.0394189
 
rms x if x>0
di r(rms)
.7423647</syntaxhighlight>
 
=={{header|Swift}}==
 
<syntaxhighlight lang="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())")</syntaxhighlight>
 
{{out}}
 
<pre>RMS of 1...10: 6.2048368229954285</pre>
 
=={{header|Tcl}}==
{{works with|Tcl|8.5}}
<langsyntaxhighlight lang="tcl">proc qmean list {
set sum 0.0
foreach value $list { set sum [expr {$sum + $value**2}] }
Line 1,518 ⟶ 2,207:
}
 
puts "RMS(1..10) = [qmean {1 2 3 4 5 6 7 8 9 10}]"</langsyntaxhighlight>
{{out}}
<pre>
Line 1,526 ⟶ 2,215:
=={{header|Ursala}}==
using the <code>mean</code> function among others from the <code>flo</code> library
<langsyntaxhighlight Ursalalang="ursala">#import nat
#import flo
 
#cast %e
 
rms = sqrt mean sqr* float* nrange(1,10)</langsyntaxhighlight>
{{out}}
<pre>
Line 1,539 ⟶ 2,228:
=={{header|Vala}}==
Valac probably needs to have the flag "-X -lm" added to include the C Math library.
<langsyntaxhighlight lang="vala">double rms(double[] list){
double sum_squares = 0;
double mean;
Line 1,557 ⟶ 2,246:
stdout.printf("%s\n", mean.to_string());
}</langsyntaxhighlight>
{{out}}
<pre>
6.2048368229954285
</pre>
 
 
=={{header|VBA}}==
Using Excel VBA
<lang vb>
<syntaxhighlight lang="vb">Private Function root_mean_square(s() As Variant) As Double
Function rms(iLow As Integer, iHigh As Integer)
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</syntaxhighlight>
Without using Excel worksheetfunction:
<syntaxhighlight lang="vb">Function rms(iLow As Integer, iHigh As Integer)
Dim i As Integer
If iLow > iHigh Then
Line 1,582 ⟶ 2,282:
Debug.Print rms(1, 10)
End Sub
</syntaxhighlight>
</lang>
 
Output:
Line 1,589 ⟶ 2,289:
</pre>
 
=={{header|V (Vlang)}}==
<syntaxhighlight lang="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))
}</syntaxhighlight>
 
{{out}}
<pre>
6.2048368229954
</pre>
 
=={{header|Wortel}}==
<langsyntaxhighlight lang="wortel">@let {
; using a composition and a fork (like you would do in J)
rms1 ^(@sqrt @(@sum / #) *^@sq)
Line 1,602 ⟶ 2,318:
!rms2 @to 10
]]
}</langsyntaxhighlight>
{{out}}
<pre>[6.2048368229954285 6.2048368229954285]</pre>
 
=={{header|Wren}}==
<syntaxhighlight lang="wren">var rms = ((1..10).reduce(0) { |acc, i| acc + i*i }/10).sqrt
System.print(rms)</syntaxhighlight>
 
{{out}}
<pre>
6.2048368229954
</pre>
 
=={{header|XLISP}}==
<langsyntaxhighlight lang="lisp">(defun quadratic-mean (xs)
(sqrt
(/
Line 1,622 ⟶ 2,347:
; test QUADRATIC-MEAN
 
(print (quadratic-mean (range 1 11)))</langsyntaxhighlight>
{{out}}
<pre>6.20483682299543</pre>
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">code CrLf=9;
code real RlOut=48;
int N;
Line 1,635 ⟶ 2,360:
RlOut(0, sqrt(S/10.0));
CrLf(0);
]</langsyntaxhighlight>
{{out}}
<pre>
Line 1,642 ⟶ 2,367:
 
=={{header|Yacas}}==
<langsyntaxhighlight Yacaslang="yacas">Sqrt(Add((1 .. 10)^2)/10)</langsyntaxhighlight>
The above will give the precise solution <math>\sqrt{\frac{77}{2}}</math>, to downgrade to 6.20483682299, surround the expression with '<code>N()</code>'.
 
=={{header|zkl}}==
<langsyntaxhighlight lang="zkl">fcn rms(z){ ( z.reduce(fcn(p,n){ p + n*n },0.0) /z.len() ).sqrt() }</langsyntaxhighlight>
The order in the reduce function is important as it coerces n*n to float.
<pre>
Anonymous user
Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/140334...350048"