Anonymous user
Averages/Root mean square: Difference between revisions
m
→{{header|Elena}}
No edit summary |
imported>Arakov |
||
(41 intermediate revisions by 28 users not shown) | |||
Line 1:
{{task}}
;Task
Compute the [[wp:Root mean square|Root mean square]] of the numbers 1..10.
Line 14:
{{Related tasks/Statistical measures}}
Line 22:
=={{header|11l}}==
{{trans|Python}}
<
R sqrt(sum(num.map(n -> n * n)) / Float(num.len))
print(qmean(1..10))</
{{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}}==
<
with Ada.Numerics.Elementary_Functions;
use Ada.Numerics.Elementary_Functions;
Line 51 ⟶ 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;</
{{out}}
<pre>
Line 61 ⟶ 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)}}
<
MODE RMSFIELD = #LONG...# REAL;
PROC (RMSFIELD)RMSFIELD rms field sqrt = #long...# sqrt;
Line 88 ⟶ 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))
)</
{{out}}
<pre>
Line 96 ⟶ 148:
=={{header|ALGOL-M}}==
Because ALGOL-M lacks a built-in square root function, we have to supply our own.
<
BEGIN
Line 132 ⟶ 184:
WRITE("RMS OF WHOLE NUMBERS 1.0 THROUGH 10.0 =", SQRT(SQMEAN));
END</
{{out}}
Based on the
<pre>
RMS OF WHOLE NUMBERS 1.0 THROUGH 10.0 = 6.20483683432
</pre>
=={{header|ALGOL W}}==
<
% computes the root-mean-square of an array of numbers with %
% the specified lower bound (lb) and upper bound (ub) %
Line 161 ⟶ 212:
write( "rms of 1 .. 10: ", rms( testNumbers, 1, 10 ) );
end.</
{{out}}
<pre>
Line 168 ⟶ 219:
=={{header|APL}}==
<
x←⍳10
rms x
6.204836823</
=={{header|AppleScript}}==
===Functional===
{{Trans|JavaScript}}( ES6 version )
<syntaxhighlight lang="applescript">--------------------- ROOT MEAN SQUARE -------------------
-- rootMeanSquare :: [Num] -> Real
on rootMeanSquare(xs)
script
Line 188 ⟶ 242:
on run
Line 197 ⟶ 251:
-- foldl :: (a -> b -> a) -> a -> [b] -> a
Line 221 ⟶ 275:
end script
end if
end mReturn</
{{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
=={{header|AutoHotkey}}==
===Using a loop===
<
Line 240 ⟶ 336:
Sum += (a + A_Index - 1) ** 2
Return, Sqrt(Sum / n)
}</
Message box shows:
<pre>
Line 251 ⟶ 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>
<
Line 258 ⟶ 354:
;---------------------------------------------------------------------------
Return, Sqrt((b*(b+1)*(2*b+1)-a*(a-1)*(2*a-1))/6/(b-a+1))
}</
Message box shows:
<pre>
Line 265 ⟶ 361:
=={{header|AWK}}==
<
# computes RMS of the 1st column of a data file
{
Line 275 ⟶ 371:
END {
print "RMS: ",sqrt(S/N);
}</
=={{header|BASIC}}==
Line 282 ⟶ 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>.
<
FOR L0 = 1 TO 10
i(L0) = L0
Line 295 ⟶ 391:
tmp = UBOUND(what) - LBOUND(what) + 1
rms# = SQR(rt / tmp)
END FUNCTION</
See also: [[#BBC BASIC|BBC BASIC]], [[#Liberty BASIC|Liberty BASIC]], [[#PureBasic|PureBasic]], [[#Run BASIC|Run BASIC]]
Line 301 ⟶ 397:
==={{header|Applesoft BASIC}}===
<
20 FOR I = 1 TO N
30 S = S + I * I
40 NEXT
50 X = SQR (S / N)
60 PRINT X</
{{out}}
<pre>6.20483683</pre>
==={{header|Craft Basic}}===
<syntaxhighlight lang="basic">precision 8
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}}===
<
110 DEF RMS(N)
120 LET R=0
Line 319 ⟶ 429:
150 NEXT
160 LET RMS=SQR(R/N)
170 END DEF</
==={{header|Sinclair ZX81 BASIC}}===
<
20 LET RMS=0
30 FOR X=1 TO 10
Line 329 ⟶ 439:
60 LET RMS=SQR (RMS/10)
70 SLOW
80 PRINT RMS</
{{out}}
<pre>6.2048368</pre>
==={{header|BBC BASIC}}===
<
array() = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Line 340 ⟶ 450:
END
DEF FNrms(a()) = MOD(a()) / SQR(DIM(a(),1)+1)</
=={{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}}==
<
#include <math.h>
Line 360 ⟶ 482:
printf("%f\n", rms(v, sizeof(v)/sizeof(double)));
return 0;
}</
=={{header|C sharp|C#}}==
<
namespace rms
Line 385 ⟶ 507:
}
}
}</
An alternative method demonstrating the more functional style introduced by LINQ and lambda expressions in C# 3.
{{works with|C sharp|C#|3}}
<
using System.Collections.Generic;
using System.Linq;
Line 406 ⟶ 528:
}
}
}</
=={{header|C++}}==
<
#include <vector>
#include <cmath>
Line 421 ⟶ 543:
std::cout << "The quadratic mean of the numbers 1 .. " << numbers.size() << " is " << meansquare << " !\n" ;
return 0 ;
}</
{{out}}
<pre>
Line 428 ⟶ 550:
=={{header|Clojure}}==
<
(defn rms [xs]
(Math/sqrt (/ (reduce + (map #(* % %) xs))
(count xs))))
(println (rms (range 1 11)))</
{{out}}
<pre>
Line 441 ⟶ 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.
<
PROGRAM-ID. QUADRATIC-MEAN-PROGRAM.
DATA DIVISION.
Line 461 ⟶ 583:
ADD 1 TO N.
MULTIPLY N BY N GIVING N-SQUARED.
ADD N-SQUARED TO RUNNING-TOTAL.</
{{out}}
<pre>6.204836822995428</pre>
Line 467 ⟶ 589:
=={{header|CoffeeScript}}==
{{trans|JavaScript}}
<
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])</
=={{header|Common Lisp}}==
<
for xx = (* x x)
for n from 1
summing xx into xx-sum
finally (return (sqrt (/ xx-sum n))))</
Here's a non-iterative solution.
<
(defun root-mean-square (numbers)
"Takes a list of numbers, returns their quadratic mean."
Line 490 ⟶ 612:
(root-mean-square (loop for i from 1 to 10 collect i))
</syntaxhighlight>
=={{header|Crystal}}==
{{trans|Ruby}}
<
Math.sqrt(seq.sum { |x| x*x } / seq.size)
end
puts rms (1..10).to_a</
{{out}}
Line 504 ⟶ 626:
=={{header|D}}==
<
real rms(R)(R d) pure {
Line 512 ⟶ 634:
void main() {
writefln("%.19f", iota(1, 11).rms);
}</
{{out}}
<pre>
Line 519 ⟶ 641:
=={{header|Delphi}}/{{header|Pascal}}==
<
{$APPTYPE CONSOLE}
Line 540 ⟶ 662:
Writeln(MeanSquare(TDoubleDynArray.Create()));
Writeln(MeanSquare(TDoubleDynArray.Create(1,2,3,4,5,6,7,8,9,10)));
end.</
=={{header|E}}==
Using the same generic mean function as used in [[../Pythagorean means#E|pythagorean means]]:
<
return def mean(numbers) {
var count := 0
Line 556 ⟶ 678:
}
def RMS := makeMean(0, fn b,x { b+x**2 }, fn acc,n { (acc/n).sqrt() })</
<
# value: 6.2048368229954285</
=={{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}}==
<
(define (rms xs)
(sqrt (// (for/sum ((x xs)) (* x x)) (length xs))))
Line 568 ⟶ 703:
(rms (range 1 11))
→ 6.2048368229954285
</syntaxhighlight>
=={{header|Elena}}==
{{trans|C#}}
ELENA
<
import system'routines;
import system'math;
Line 580 ⟶ 715:
{
get RootMeanSquare()
= (self.selectBy::(x => x * x).summarize(Real.new()) / self.Length).sqrt();
}
Line 586 ⟶ 721:
{
console.printLine(new Range(1, 10).RootMeanSquare)
}</
{{out}}
<pre>
Line 593 ⟶ 728:
=={{header|Elixir}}==
<
defmodule RC do
def root_mean_square(enum) do
Line 608 ⟶ 743:
IO.puts RC.root_mean_square(1..10)
</syntaxhighlight>
{{out}}
<pre>
Line 615 ⟶ 750:
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(defun rms (nums)
(sqrt (/ (apply '+ (mapcar (lambda (x) (* x x)) nums))
(rms (number-sequence 1 10))</syntaxhighlight>
{{out}}
<pre>6.2048368229954285</pre>
=={{header|Erlang}}==
<
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]).</
{{out}}
<pre>6.2048368229954285</pre>
=={{header|ERRE}}==
<syntaxhighlight lang="text">
PROGRAM ROOT_MEAN_SQUARE
BEGIN
Line 653 ⟶ 778:
PRINT("Root mean square is";X)
END PROGRAM
</syntaxhighlight>
You can, obviously, generalize reading data from a DATA line or from a file.
=={{header|Euphoria}}==
<
atom sum
if length(s) = 0 then
Line 670 ⟶ 795:
constant s = {1,2,3,4,5,6,7,8,9,10}
? rms(s)</
{{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
<
=SQRT(SUMSQ($A1:$A10)/COUNT($A1:$A10))
</syntaxhighlight>
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.
<
let res = RMS [1.0..10.0]</
Answer (in F# Interactive window):
<pre>val res : float = 6.204836823</pre>
=={{header|Factor}}==
<
[ [ sq ] map-sum ] [ length ] bi / sqrt ;</
( scratchpad ) 10 [1,b] root-mean-square .
Line 698 ⟶ 865:
=={{header|Fantom}}==
<
{
static Float averageRms (Float[] nums)
Line 713 ⟶ 880:
echo ("RMS Average of $a is: " + averageRms(a))
}
}</
=={{header|Forth}}==
<
dup >r 0e
floats bounds do
Line 724 ⟶ 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</
=={{header|Fortran}}==
Assume <math> x </math> stored in array x.
<
=={{header|FreeBASIC}}==
<
' FB 1.05.0 Win64
Line 752 ⟶ 919:
Print "Press any key to quit the program"
Sleep
</syntaxhighlight>
{{out}}
Line 761 ⟶ 928:
=={{header|Futhark}}==
<syntaxhighlight lang="futhark">
import "futlib/math"
fun main(as: [n]f64): f64 =
f64.sqrt ((reduce (+) 0.0 (map (**2.0) as)) / f64(n))
</syntaxhighlight>
=={{header|GEORGE}}==
<syntaxhighlight lang="george">
1, 10 rep (i)
i i | (v) ;
Line 779 ⟶ 946:
sqrt
print
</syntaxhighlight>
<pre>
6.204836822995428
Line 785 ⟶ 952:
=={{header|Go}}==
<
import (
Line 799 ⟶ 966:
}
fmt.Println(math.Sqrt(sum / n))
}</
{{out}}
<pre>
Line 807 ⟶ 974:
=={{header|Groovy}}==
Solution:
<
list == null \
? null \
Line 813 ⟶ 980:
? 0 \
: ((list.collect { it*it }.sum()) / list.size()) ** 0.5
}</
Test:
<
def Q = quadMean(list)
println """
list: ${list}
Q: ${Q}
"""</
{{out}}
<pre>list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Line 827 ⟶ 994:
=={{header|Haskell}}==
Given the <code>mean</code> function defined in [[Averages/Pythagorean means]]:
<
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/):
<
rootMeanSquare :: [Double] -> Double
Line 837 ⟶ 1,004:
main :: IO ()
main = print $ rootMeanSquare [1 .. 10]</
{{Out}}
<pre>6.2048368229954285</pre>
=={{header|HicEst}}==
<
DO i = 1, 10
sum = sum + i^2
ENDDO
WRITE(ClipBoard) "RMS(1..10) = ", (sum/10)^0.5 </
RMS(1..10) = 6.204836823
=={{header|Icon}} and {{header|Unicon}}==
<
every put(x := [], 1 to 10)
writes("x := [ "); every writes(!x," "); write("]")
write("Quadratic mean:",q := qmean!x)
end</
<
local m
if *L = 0 then fail
every (m := 0.0) +:= !L^2
return sqrt(m / *L)
end</
=={{header|Io}}==
<
rms( Range 1 to(10) asList ) println</
=={{header|J}}==
'''Solution:'''
<
'''Example Usage:'''
<
6.20484</
<code>*:</code> means [http://jsoftware.com/help/dictionary/d112.htm square]
Line 883 ⟶ 1,050:
=={{header|Java}}==
<
public static double rootMeanSquare(double... nums) {
Line 896 ⟶ 1,063:
System.out.println("The RMS of the numbers from 1 to 10 is " + rootMeanSquare(nums));
}
}</
{{out}}
<pre>The RMS of the numbers from 1 to 10 is 6.2048368229954285</pre>
Line 904 ⟶ 1,071:
{{works with|JavaScript|1.8}}
{{works with|Firefox|3.0}}
<
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</
===ES6===
<
'use strict';
Line 931 ⟶ 1,098:
// -> 6.2048368229954285
})();</
{{Out}}
Line 938 ⟶ 1,105:
=={{header|jq}}==
The following filter returns ''null'' if given an empty array:
<
| if $length == 0 then null
else map(. * .) | add | sqrt / $length
end ;</
=={{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:
<
or shorter with using Statistics (and as spoken: root-mean-square)
<
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: <
One can also use an explicit loop for near-C performance
<
function rms(A)
s = 0.0
Line 958 ⟶ 1,125:
return sqrt(s / length(A))
end
</syntaxhighlight>
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): <
=={{header|K}}==
<syntaxhighlight lang="k">
rms:{_sqrt (+/x^2)%#x}
rms 1+!10
6.204837
</syntaxhighlight>
=={{header|Kotlin}}==
<
fun quadraticMean(vector: Array<Double>) : Double {
Line 979 ⟶ 1,146:
val vector = Array(10, { (it + 1).toDouble() })
print("Quadratic mean of numbers 1 to 10 is ${quadraticMean(vector)}")
}</
{{out}}
Line 985 ⟶ 1,152:
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}}==
<
return math_sqrt((with n in #a sum #n*#n) / decimal(#a->size))
}
rms(generateSeries(1,10)->asStaticArray)</
{{out}}
Line 996 ⟶ 1,177:
=={{header|Liberty BASIC}}==
<
SourceList$ ="1 2 3 4 5 6 7 8 9 10"
Line 1,021 ⟶ 1,202:
print "R.M.S. value is "; ( SumOfSquares /n)^0.5
end</
=={{header|Logo}}==
<
output sqrt quotient (apply "sum map [? * ?] :v) count :v
end
show rms iseq 1 10</
=={{header|Lua}}==
<
function rms(t) return (sumsq(unpack(t)) / #t)^.5 end
print(rms{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})</
=={{header|Maple}}==
<
RMS := proc( x )
return sqrt( Statistics:-Mean( x ^~ 2 ) );
end proc:
RMS( y );
</syntaxhighlight>
{{out}}
<pre>6.20483682299543
Line 1,048 ⟶ 1,229:
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang
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}}==
<
rms = sqrt(mean(list.^2));
end</
Solution:
<
ans =
6.204836822995429</
=={{header|Maxima}}==
<
rms(L) := sqrt(lsum(x^2, x, L)/length(L))$
rms(L), numer; /* 6.204836822995429 */</
=={{header|MAXScript}}==
<syntaxhighlight lang="maxscript">
fn RMS arr =
(
Line 1,077 ⟶ 1,258:
return (sqrt (sumSquared/arr.count as float))
)
</syntaxhighlight>
Output:
<syntaxhighlight lang="maxscript">
rms #{1..10}
6.20484
</syntaxhighlight>
=={{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</
''Instruction:'' В/О С/П Number С/П Number ...
Line 1,095 ⟶ 1,284:
=={{header|Morfa}}==
{{trans|D}}
<
import morfa.base;
import morfa.functional.base;
Line 1,110 ⟶ 1,299:
println(rms(1 .. 11));
}
</syntaxhighlight>
{{out}}
<pre>
Line 1,117 ⟶ 1,306:
=={{header|Nemerle}}==
<
using System.Console;
using System.Math;
Line 1,133 ⟶ 1,322:
WriteLine("RMS of [1 .. 10]: {0:g6}", RMS($[1 .. 10]));
}
}</
=={{header|NetRexx}}==
<
options replace format comments java crossref symbols nobinary
Line 1,151 ⟶ 1,340:
return
</syntaxhighlight>
{{out}}
<pre>
Line 1,158 ⟶ 1,347:
=={{header|Nim}}==
<
from sequtils import mapIt
Line 1,165 ⟶ 1,354:
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])</
{{out}}
<pre>6.
=={{header|Oberon-2}}==
Oxford Oberon-2
<
MODULE QM;
IMPORT ML := MathL, Out;
Line 1,196 ⟶ 1,385:
Out.String("Quadratic Mean: ");Out.LongReal(Rms(nums));Out.Ln
END QM.
</syntaxhighlight>
{{out}}
<pre>
Line 1,203 ⟶ 1,392:
=={{header|Objeck}}==
<
class Hello {
function : Main(args : String[]) ~ Nil {
Line 1,220 ⟶ 1,409:
}
}
}</
=={{header|OCaml}}==
<
sqrt (Array.fold_left (fun s x -> s +. x*.x) 0.0 a /.
float_of_int (Array.length a))
Line 1,229 ⟶ 1,418:
rms (Array.init 10 (fun i -> float_of_int (i+1))) ;;
(* 6.2048368229954285 *)</
=={{header|Oforth}}==
<
{{out}}
Line 1,241 ⟶ 1,430:
=={{header|ooRexx}}==
<
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,262 ⟶ 1,451:
return rxcalcsqrt(sum/numbers~items)
::requires rxmath LIBRARY</
{{out}}
<pre>list = 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
Line 1,274 ⟶ 1,463:
=={{header|Oz}}==
<
fun {Square X} X*X end
Line 1,284 ⟶ 1,473:
end
in
{Show {RMS {List.number 1 10 1}}}</
{{out}}
<pre>
Line 1,292 ⟶ 1,481:
=={{header|PARI/GP}}==
General RMS calculation:
<
sqrt(sum(i=1,#v,v[i]^2)/#v)
};
RMS(vector(10,i,i))</
Specific functions for the first ''n'' positive integers:
<
sqrt((n+1)*(2*n+1)/6)
};
RMS_first(10)</
Asymptotically this is n/sqrt(3).
=={{header|Perl}}==
<
sub rms
{
Line 1,315 ⟶ 1,504:
}
say rms(1..10);</
=={{header|Phix}}==
<!--<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: #000000;">0</span>
<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>
<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>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</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: #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}}==
<
0 swap
len for
Line 1,346 ⟶ 1,547:
endfor
rms print</
=={{header|PHP}}==
<
// Created with PHP 7.0
Line 1,364 ⟶ 1,565:
echo rms(array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
</syntaxhighlight>
{{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}}==
<
(let Lst (1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0)
Line 1,382 ⟶ 1,607:
(length Lst) )
T )
*Scl ) ) )</
{{out}}
<pre>6.20484</pre>
=={{header|PL/I}}==
<
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,393 ⟶ 1,618:
RMS = sqrt(sum(A**2)/n);
put Skip Data(rms);
End;</
{{out}}
<pre>RMS= 6.20483682299543E+0000;</pre>
=={{header|PostScript}}==
<
/x exch def
/sum 0 def
Line 1,413 ⟶ 1,638:
}def
[1 2 3 4 5 6 7 8 9 10] findrms</
{{out}}
<pre>
Line 1,419 ⟶ 1,644:
</pre>
{{libheader|initlib}}
<
=={{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}}==
<
decimal ld_rms
Line 1,433 ⟶ 1,669:
ld_rms = Sqrt(ll_product / ll_y)
//ld_rms value is 6.20483682299542849</
=={{header|PowerShell}}==
<
$sqsum=$nums | foreach-object { $_*$_} | measure-object -sum | select-object -expand Sum
return [math]::sqrt($sqsum/$nums.count)
}
get-rms @(1..10) </
=={{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}}==
<
If OpenConsole()
Line 1,470 ⟶ 1,749:
PrintN("Press ENTER to exit"): Input()
CloseConsole()
EndIf</
=={{header|Python}}==
{{works with|Python|3}}
<
>>> def qmean(num):
return sqrt(sum(n*n for n in num)/len(num))
>>> qmean(range(1,11))
6.2048368229954285</
<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>
Line 1,486 ⟶ 1,765:
Alternatively in terms of '''reduce''':
<
from math import (sqrt)
Line 1,497 ⟶ 1,776:
print(
rootMeanSquare([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
)</
{{Out}}
<pre>6.2048368229954285</pre>
=={{header|Qi}}==
<
R -> (sqrt (/ (APPLY + (MAPCAR * R R)) (length R))))</
=={{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}}==
The following function works for any vector x:
<
RMS(1:10)
# [1] 6.204837
RMS(c(NA, 1:10))
# [1] NA
RMS(c(NA, 1:10), na.rm = T)
# [1] 6.204837</syntaxhighlight>
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
(define (rms nums)
(sqrt (/ (for/sum ([n nums]) (* n n)) (length nums))))
</syntaxhighlight>
=={{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"
=={{header|REXX}}==
Line 1,541 ⟶ 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.
<
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,559 ⟶ 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</
'''output''' when using the default inputs:
<pre>
Line 1,566 ⟶ 1,888:
=={{header|Ring}}==
<
nums = [1,2,3,4,5,6,7,8,9,10]
sum = 0
Line 1,578 ⟶ 1,900:
x = sqrt(sum / len(number))
return x
</syntaxhighlight>
=={{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}}==
<
def quadratic_mean
Math.sqrt( self.inject(0.0) {|s, y| s + y*y} / self.length )
Line 1,593 ⟶ 1,930:
end
(1..10).quadratic_mean # => 6.2048368229954285</
and a non object-oriented solution:
<
Math.sqrt(seq.
end
puts rms (1..10)
=={{header|Run BASIC}}==
<
while word$(valueList$,i +1) <> "" ' grab values from list
thisValue = val(word$(valueList$,i +1)) ' turn values into numbers
Line 1,609 ⟶ 1,946:
wend
print "List of Values:";valueList$;" containing ";i;" values"
print "Root Mean Square =";(sumSquares/i)^0.5</
{{out}}
Line 1,616 ⟶ 1,953:
=={{header|Rust}}==
<
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,624 ⟶ 1,961:
let vec = (1..11).collect();
println!("The root mean square is: {}", root_mean_square(vec));
}</
{{out}}
Line 1,637 ⟶ 1,974:
built-in syntax.
<
{
return sqrt(sum(sqr(arr)) / length(arr));
}
print(rms([1:10]));</
=={{header|Sather}}==
<
-- irrms stands for Integer Ranged RMS
irrms(i, f:INT):FLT
Line 1,660 ⟶ 1,997:
#OUT + irrms(1, 10) + "\n";
end;
end;</
=={{header|S-BASIC}}==
<
var n, sqsum, sqmean, rms = real
sqsum = 0
Line 1,674 ⟶ 2,011:
end
</syntaxhighlight>
{{out}}
<pre>
Line 1,681 ⟶ 2,018:
=={{header|Scala}}==
<
println(rms(1 to 10))</
{{out}}
<pre>6.2048368229954285</pre>
=={{header|Scheme}}==
<
(sqrt (/ (apply + (map * nums nums))
(length nums))))
(rms '(1 2 3 4 5 6 7 8 9 10))</
{{out}}
<pre>6.20483682299543</pre>
=={{header|Seed7}}==
<
include "float.s7i";
include "math.s7i";
Line 1,718 ⟶ 2,055:
begin
writeln(rms(numbers) digits 7);
end func;</
=={{header|Shen}}==
{{works with|shen-scheme|0.17}}
<
(tc +)
Line 1,747 ⟶ 2,084:
Lim -> (iota-h 1 Lim))
(output "~A~%" (rms (iota 10)))</
=={{header|Sidef}}==
<
sqrt(a.map{.**2}.sum / a.len)
}
say rms(1..10)</
Using hyper operators, we can write it as:
<
{{out}}
Line 1,763 ⟶ 2,100:
=={{header|Smalltalk}}==
<
=={{header|SNOBOL4}}==
Line 1,769 ⟶ 2,106:
{{works with|CSnobol}}
There is no built-in sqrt( ) function in Snobol4+.
<
rms i = i + 1; ssq = ssq + (a<i> * a<i>) :s(rms)
rms = sqrt(1.0 * ssq / prototype(a)) :(return)
Line 1,778 ⟶ 2,115:
loop i = i + 1; str len(p) span('0123456789') . a<i> @p :s(loop)
output = str ' -> ' rms(a)
end</
{{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}}==
<
let
val v' = Vector.map (fn x => x*x) v
Line 1,791 ⟶ 2,155:
end;
rms(Vector.tabulate(10, fn n => real(n+1)));</
{{out}}
<pre>val it = 6.204836823 : real</pre>
Line 1,798 ⟶ 2,162:
Compute the RMS of a variable and return the result in r(rms).
<
syntax varname(numeric) [if] [in]
tempvar x
Line 1,804 ⟶ 2,168:
qui sum `x' `if' `in'
return scalar rms=sqrt(r(mean))
end</
'''Example'''
<
set obs 20
gen x=rnormal()
Line 1,818 ⟶ 2,182:
rms x if x>0
di r(rms)
.7423647</
=={{header|Swift}}==
<
@inlinable
public func rms() -> Element {
Line 1,829 ⟶ 2,193:
}
print("RMS of 1...10: \((1...10).map(Double.init).rms())")</
{{out}}
Line 1,837 ⟶ 2,201:
=={{header|Tcl}}==
{{works with|Tcl|8.5}}
<
set sum 0.0
foreach value $list { set sum [expr {$sum + $value**2}] }
Line 1,843 ⟶ 2,207:
}
puts "RMS(1..10) = [qmean {1 2 3 4 5 6 7 8 9 10}]"</
{{out}}
<pre>
Line 1,851 ⟶ 2,215:
=={{header|Ursala}}==
using the <code>mean</code> function among others from the <code>flo</code> library
<
#import flo
#cast %e
rms = sqrt mean sqr* float* nrange(1,10)</
{{out}}
<pre>
Line 1,864 ⟶ 2,228:
=={{header|Vala}}==
Valac probably needs to have the flag "-X -lm" added to include the C Math library.
<
double sum_squares = 0;
double mean;
Line 1,882 ⟶ 2,246:
stdout.printf("%s\n", mean.to_string());
}</
{{out}}
<pre>
Line 1,890 ⟶ 2,254:
=={{header|VBA}}==
Using Excel VBA
<
For i = 1 To UBound(s)
s(i) = s(i) ^ 2
Line 1,900 ⟶ 2,264:
s = [{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}]
Debug.Print root_mean_square(s)
End Sub</
Without using Excel worksheetfunction:
<
Dim i As Integer
If iLow > iHigh Then
Line 1,918 ⟶ 2,282:
Debug.Print rms(1, 10)
End Sub
</syntaxhighlight>
Output:
<pre>
6.20483682299543
</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}}==
<
; using a composition and a fork (like you would do in J)
rms1 ^(@sqrt @(@sum / #) *^@sq)
Line 1,937 ⟶ 2,318:
!rms2 @to 10
]]
}</
{{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}}==
<
(sqrt
(/
Line 1,957 ⟶ 2,347:
; test QUADRATIC-MEAN
(print (quadratic-mean (range 1 11)))</
{{out}}
<pre>6.20483682299543</pre>
=={{header|XPL0}}==
<
code real RlOut=48;
int N;
Line 1,970 ⟶ 2,360:
RlOut(0, sqrt(S/10.0));
CrLf(0);
]</
{{out}}
<pre>
Line 1,977 ⟶ 2,367:
=={{header|Yacas}}==
<
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}}==
<
The order in the reduce function is important as it coerces n*n to float.
<pre>
|