Averages/Root mean square: Difference between revisions

=={{header|11l}}==

{{trans|Python}}

R sqrt(sum(num.map(n -> n * n)) / Float(num.len))

 

{{out}}

<pre>

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

BYTE FUNC Equal(REAL POINTER a,b)

Print("RMS of 1..10 is ")

PrintRE(x)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Root_mean_square.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

with Ada.Numerics.Elementary_Functions;

use Ada.Numerics.Elementary_Functions;

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);

{{out}}

<pre>

{{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;

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>

=={{header|ALGOL-M}}==

Because ALGOL-M lacks a built-in square root function, we have to supply our own.

BEGIN

 

WRITE("RMS OF WHOLE NUMBERS 1.0 THROUGH 10.0 =", SQRT(SQMEAN));

 

{{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).

 

=={{header|ALGOL W}}==

% computes the root-mean-square of an array of numbers with %

% the specified lower bound (lb) and upper bound (ub) %

write( "rms of 1 .. 10: ", rms( testNumbers, 1, 10 ) );

 

{{out}}

<pre>

 

=={{header|APL}}==

x←⍳10

 

rms x

 

=={{header|AppleScript}}==

{{Trans|JavaScript}}( ES6 version )

on rootMeanSquare(xs)

script

end script

end if

{{Out}}

<pre>6.204836822995</pre>

=={{header|Arturo}}==

 

sqrt (sum map arr 'i -> i^2) // size arr

 

 

{{out}}

 

=={{header|Astro}}==

 

=={{header|AutoHotkey}}==

===Using a loop===

 

 

Sum += (a + A_Index - 1) ** 2

Return, Sqrt(Sum / n)

Message box shows:

<pre>

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>

 

 

;---------------------------------------------------------------------------

Return, Sqrt((b*(b+1)*(2*b+1)-a*(a-1)*(2*a-1))/6/(b-a+1))

Message box shows:

<pre>

 

=={{header|AWK}}==

# computes RMS of the 1st column of a data file

{

END {

print "RMS: ",sqrt(S/N);

 

=={{header|BASIC}}==

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

tmp = UBOUND(what) - LBOUND(what) + 1

rms# = SQR(rt / tmp)

 

See also: [[#BBC BASIC|BBC BASIC]], [[#Liberty BASIC|Liberty BASIC]], [[#PureBasic|PureBasic]], [[#Run BASIC|Run BASIC]]

==={{header|Applesoft BASIC}}===

 

20 FOR I = 1 TO N

30 S = S + I * I

40 NEXT

50 X = SQR (S / N)

 

{{out}}

 

==={{header|IS-BASIC}}===

110 DEF RMS(N)

120 LET R=0

150 NEXT

160 LET RMS=SQR(R/N)

 

==={{header|Sinclair ZX81 BASIC}}===

20 LET RMS=0

30 FOR X=1 TO 10

60 LET RMS=SQR (RMS/10)

70 SLOW

{{out}}

<pre>6.2048368</pre>

 

==={{header|BBC BASIC}}===

array() = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

END

 

=={{header|BQN}}==

RMS is a tacit function which computes root mean square.

 

 

[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.

 

=={{header|C}}==

#include <math.h>

 

printf("%f\n", rms(v, sizeof(v)/sizeof(double)));

return 0;

 

=={{header|C sharp|C#}}==

 

namespace rms

}

}

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;

}

}

 

=={{header|C++}}==

#include <vector>

#include <cmath>

std::cout << "The quadratic mean of the numbers 1 .. " << numbers.size() << " is " << meansquare << " !\n" ;

return 0 ;

{{out}}

<pre>

 

=={{header|Clojure}}==

(defn rms [xs]

(Math/sqrt (/ (reduce + (map #(* % %) xs))

(count xs))))

 

{{out}}

<pre>

=={{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.

ADD 1 TO N.

MULTIPLY N BY N GIVING N-SQUARED.

{{out}}

<pre>6.204836822995428</pre>

=={{header|CoffeeScript}}==

{{trans|JavaScript}}

sum_of_squares = ary.reduce ((s,x) -> s + x*x), 0

return Math.sqrt(sum_of_squares / ary.length)

 

=={{header|Common Lisp}}==

for xx = (* x x)

for n from 1

summing xx into xx-sum

 

Here's a non-iterative solution.

 

(defun root-mean-square (numbers)

"Takes a list of numbers, returns their quadratic mean."

 

(root-mean-square (loop for i from 1 to 10 collect i))

 

=={{header|Crystal}}==

{{trans|Ruby}}

Math.sqrt(seq.sum { |x| x*x } / seq.size)

end

 

 

{{out}}

 

=={{header|D}}==

 

real rms(R)(R d) pure {

void main() {

writefln("%.19f", iota(1, 11).rms);

{{out}}

<pre>

 

=={{header|Delphi}}/{{header|Pascal}}==

 

{$APPTYPE CONSOLE}

Writeln(MeanSquare(TDoubleDynArray.Create()));

Writeln(MeanSquare(TDoubleDynArray.Create(1,2,3,4,5,6,7,8,9,10)));

 

=={{header|E}}==

Using the same generic mean function as used in [[../Pythagorean means#E|pythagorean means]]:

return def mean(numbers) {

var count := 0

}

 

 

 

=={{header|EchoLisp}}==

(define (rms xs)

(sqrt (// (for/sum ((x xs)) (* x x)) (length xs))))

(rms (range 1 11))

→ 6.2048368229954285

 

=={{header|Elena}}==

{{trans|C#}}

ELENA 5.0 :

import system'routines;

import system'math;

{

console.printLine(new Range(1, 10).RootMeanSquare)

{{out}}

<pre>

 

=={{header|Elixir}}==

defmodule RC do

def root_mean_square(enum) do

 

IO.puts RC.root_mean_square(1..10)

{{out}}

<pre>

(float (length nums)))))

 

 

{{out}}

 

=={{header|Erlang}}==

math:sqrt(lists:foldl(fun(E,S) -> S+E*E end, 0, Nums) / length(Nums)).

 

{{out}}

<pre>6.2048368229954285</pre>

PRINT("Root mean square is";X)

END PROGRAM

You can, obviously, generalize reading data from a DATA line or from a file.

 

=={{header|Euphoria}}==

atom sum

if length(s) = 0 then

 

constant s = {1,2,3,4,5,6,7,8,9,10}

{{out}}

<pre>6.204836823</pre>

===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))

 

The RMS of [1,10] is then : 6.204836823 ( Actual displayed value 6.204837)

{{Works with|Office 365 betas 2021}}

 

=LAMBDA(xs,

SQRT(SUMSQ(xs)/COUNT(xs))

 

For this test, we assume that the following generic lambda is also bound to the name ENUMFROMTO in the Name Manager:

 

=LAMBDA(a,

LAMBDA(z,

SEQUENCE(1 + z - a, 1, a, 1)

)

 

{{Out}}

=={{header|F Sharp|F#}}==

Uses a lambda expression and function piping.

 

Answer (in F# Interactive window):

<pre>val res : float = 6.204836823</pre>

 

=={{header|Factor}}==

 

( scratchpad ) 10 [1,b] root-mean-square .

 

=={{header|Fantom}}==

{

static Float averageRms (Float[] nums)

echo ("RMS Average of $a is: " + averageRms(a))

}

 

=={{header|Forth}}==

dup >r 0e

floats bounds do

 

create test 1e f, 2e f, 3e f, 4e f, 5e f, 6e f, 7e f, 8e f, 9e f, 10e f,

 

=={{header|Fortran}}==

Assume <math> x </math> stored in array x.

 

=={{header|FreeBASIC}}==

' FB 1.05.0 Win64

 

Print "Press any key to quit the program"

Sleep

 

{{out}}

=={{header|Futhark}}==

 

import "futlib/math"

 

fun main(as: [n]f64): f64 =

f64.sqrt ((reduce (+) 0.0 (map (**2.0) as)) / f64(n))

 

=={{header|GEORGE}}==

1, 10 rep (i)

i i | (v) ;

sqrt

print

<pre>

6.204836822995428

 

=={{header|Go}}==

 

import (

}

fmt.Println(math.Sqrt(sum / n))

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

list == null \

? null \

? 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]

=={{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

 

main :: IO ()

{{Out}}

<pre>6.2048368229954285</pre>

 

=={{header|HicEst}}==

DO i = 1, 10

sum = sum + i^2

ENDDO

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)

 

 

local m

if *L = 0 then fail

every (m := 0.0) +:= !L^2

return sqrt(m / *L)

 

=={{header|Io}}==

 

 

=={{header|J}}==

'''Solution:'''

 

'''Example Usage:'''

<code>*:</code> means [http://jsoftware.com/help/dictionary/d112.htm square]

 

 

=={{header|Java}}==

 

public static double rootMeanSquare(double... nums) {

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>

{{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);

}

 

 

 

===ES6===

 

'use strict';

// -> 6.2048368229954285

 

{{Out}}

=={{header|jq}}==

The following filter returns ''null'' if given an empty array:

| if $length == 0 then null

else map(. * .) | add | sqrt / $length

 

=={{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)

One can also use an explicit loop for near-C performance

function rms(A)

s = 0.0

return sqrt(s / length(A))

end

 

=={{header|K}}==

rms:{_sqrt (+/x^2)%#x}

rms 1+!10

6.204837

 

=={{header|Kotlin}}==

 

fun quadraticMean(vector: Array<Double>) : Double {

val vector = Array(10, { (it + 1).toDouble() })

print("Quadratic mean of numbers 1 to 10 is ${quadraticMean(vector)}")

 

{{out}}

 

=={{header|Lasso}}==

return math_sqrt((with n in #a sum #n*#n) / decimal(#a->size))

}

 

{{out}}

 

=={{header|Liberty BASIC}}==

 

SourceList$ ="1 2 3 4 5 6 7 8 9 10"

print "R.M.S. value is "; ( SumOfSquares /n)^0.5

 

 

=={{header|Logo}}==

output sqrt quotient (apply "sum map [? * ?] :v) count :v

end

 

 

=={{header|Lua}}==

function rms(t) return (sumsq(unpack(t)) / #t)^.5 end

 

 

=={{header|Maple}}==

RMS := proc( x )

return sqrt( Statistics:-Mean( x ^~ 2 ) );

end proc:

RMS( y );

{{out}}

<pre>6.20483682299543

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

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));

Solution:

 

ans =

 

 

=={{header|Maxima}}==

 

rms(L) := sqrt(lsum(x^2, x, L)/length(L))$

 

 

=={{header|MAXScript}}==

fn RMS arr =

(

return (sqrt (sumSquared/arr.count as float))

)

Output:

rms #{1..10}

6.20484

 

=={{header|min}}==

{{works with|min|0.19.6}}

('sq map sum) :sum-sq

(('sum-sq 'size) => cleave / sqrt) :rms

 

{{out}}

<pre>

<lang>0 П0 П1 С/П x^2 ИП0 x^2 ИП1 *

+ ИП1 1 + П1 / КвКор П0 БП

 

''Instruction:'' В/О С/П Number С/П Number ...

=={{header|Morfa}}==

{{trans|D}}

import morfa.base;

import morfa.functional.base;

println(rms(1 .. 11));

}

{{out}}

<pre>

 

=={{header|Nemerle}}==

using System.Console;

using System.Math;

WriteLine("RMS of [1 .. 10]: {0:g6}", RMS($[1 .. 10]));

}

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

 

return

{{out}}

<pre>

 

=={{header|Nim}}==

from sequtils import mapIt

result = sqrt(result / float(num.len))

{{out}}

<pre>6.204836822995428</pre>

=={{header|Oberon-2}}==

Oxford Oberon-2

MODULE QM;

IMPORT ML := MathL, Out;

Out.String("Quadratic Mean: ");Out.LongReal(Rms(nums));Out.Ln

END QM.

{{out}}

<pre>

 

=={{header|Objeck}}==

class Hello {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|OCaml}}==

sqrt (Array.fold_left (fun s x -> s +. x*.x) 0.0 a /.

float_of_int (Array.length a))

 

rms (Array.init 10 (fun i -> float_of_int (i+1))) ;;

 

=={{header|Oforth}}==

 

 

{{out}}

 

=={{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)

return rxcalcsqrt(sum/numbers~items)

 

{{out}}

<pre>list = 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

 

=={{header|Oz}}==

fun {Square X} X*X end

 

end

in

{{out}}

<pre>

=={{header|PARI/GP}}==

General RMS calculation:

sqrt(sum(i=1,#v,v[i]^2)/#v)

};

 

 

Specific functions for the first ''n'' positive integers:

sqrt((n+1)*(2*n+1)/6)

};

 

Asymptotically this is n/sqrt(3).

 

=={{header|Perl}}==

sub rms

{

}

 

 

=={{header|Phix}}==

<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: #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>

{{out}}

<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.

<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: #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>

 

=={{header|Phixmonti}}==

0 swap

len for

endfor

 

=={{header|PHP}}==

// Created with PHP 7.0

 

 

echo rms(array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));

{{out}}

<pre>

{{trans|Prolog}}

{{works with|Picat}}

rms(Xs) = Y =>

Sum = sum_of_squares(Xs),

Y = rms(1..10),

printf("The root-mean-square of 1..10 is %f\n", Y).

{{out}}

<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)

(length Lst) )

T )

{{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);

RMS = sqrt(sum(A**2)/n);

put Skip Data(rms);

{{out}}

<pre>RMS= 6.20483682299543E+0000;</pre>

 

=={{header|PostScript}}==

/x exch def

/sum 0 def

}def

 

{{out}}

<pre>

</pre>

{{libheader|initlib}}

 

=={{header|Potion}}==

total = 0.0

series each (x): total += x * x.

.

 

 

 

=={{header|Powerbuilder}}==

decimal ld_rms

 

ld_rms = Sqrt(ll_product / ll_y)

 

 

=={{header|PowerShell}}==

$sqsum=$nums | foreach-object { $_*$_} | measure-object -sum | select-object -expand Sum

return [math]::sqrt($sqsum/$nums.count)

}

 

 

=={{header|Processing}}==

float[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

print(rms(numbers));

mean = sqrt(mean / nums.length);

return mean;

{{out}}

<pre>6.204837</pre>

=={{header|Prolog}}==

{{works with|GNU Prolog}}

:- initialization(main).

 

rms(Xs, Y),

format('The root-mean-square of 1..10 is ~f\n', [Y]).

{{out}}

<pre>

 

=={{header|PureBasic}}==

 

If OpenConsole()

PrintN("Press ENTER to exit"): Input()

CloseConsole()

 

=={{header|Python}}==

{{works with|Python|3}}

>>> def qmean(num):

return sqrt(sum(n*n for n in num)/len(num))

 

>>> qmean(range(1,11))

<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>

 

 

Alternatively in terms of '''reduce''':

from math import (sqrt)

 

print(

rootMeanSquare([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

{{Out}}

<pre>6.2048368229954285</pre>

 

=={{header|Qi}}==

 

 

Using the Quackery big number rational arithmetic library <code>bigrat.qky</code>.

 

 

[ [] swap

80 rms

 

{{out}}

 

The following function works for any vector x:

 

RMS(1:10)

 

RMS(c(NA, 1:10), na.rm = T)

 

=={{header|Racket}}==

#lang racket

(define (rms nums)

(sqrt (/ (for/sum ([n nums]) (* n n)) (length nums))))

 

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2015.12}}

 

 

Here's a slightly more concise version, albeit arguably less readable:

 

=={{header|REXX}}==

<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.*/

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*/

'''output''' &nbsp; when using the default inputs:

<pre>

 

=={{header|Ring}}==

nums = [1,2,3,4,5,6,7,8,9,10]

sum = 0

x = sqrt(sum / len(number))

return x

 

=={{header|Ruby}}==

def quadratic_mean

Math.sqrt( self.inject(0.0) {|s, y| s + y*y} / self.length )

end

 

 

and a non object-oriented solution:

Math.sqrt(seq.sum{|x| x*x}.fdiv(seq.size) )

end

 

=={{header|Run BASIC}}==

while word$(valueList$,i +1) <> "" ' grab values from list

thisValue = val(word$(valueList$,i +1)) ' turn values into numbers

wend

print "List of Values:";valueList$;" containing ";i;" values"

 

{{out}}

 

=={{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();

let vec = (1..11).collect();

println!("The root mean square is: {}", root_mean_square(vec));

 

{{out}}

built-in syntax.

 

{

return sqrt(sum(sqr(arr)) / length(arr));

}

 

 

=={{header|Sather}}==

-- irrms stands for Integer Ranged RMS

irrms(i, f:INT):FLT

#OUT + irrms(1, 10) + "\n";

end;

 

=={{header|S-BASIC}}==

var n, sqsum, sqmean, rms = real

sqsum = 0

 

end

{{out}}

<pre>

 

=={{header|Scala}}==

{{out}}

<pre>6.2048368229954285</pre>

 

=={{header|Scheme}}==

(sqrt (/ (apply + (map * nums nums))

(length nums))))

 

{{out}}

<pre>6.20483682299543</pre>

 

=={{header|Seed7}}==

include "float.s7i";

include "math.s7i";

begin

writeln(rms(numbers) digits 7);

 

=={{header|Shen}}==

{{works with|shen-scheme|0.17}}

 

(tc +)

Lim -> (iota-h 1 Lim))

 

 

=={{header|Sidef}}==

sqrt(a.map{.**2}.sum / a.len)

}

 

 

Using hyper operators, we can write it as:

 

{{out}}

 

=={{header|Smalltalk}}==

 

=={{header|SNOBOL4}}==

{{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)

loop i = i + 1; str len(p) span('0123456789') . a<i> @p :s(loop)

output = str ' -> ' rms(a)

{{out}}

<pre>1 2 3 4 5 6 7 8 9 10 -> 6.20483682</pre>

 

=={{header|Standard ML}}==

let

val v' = Vector.map (fn x => x*x) v

end;

 

{{out}}

<pre>val it = 6.204836823 : real</pre>

Compute the RMS of a variable and return the result in r(rms).

 

syntax varname(numeric) [if] [in]

tempvar x

qui sum `x' `if' `in'

return scalar rms=sqrt(r(mean))

 

'''Example'''

 

set obs 20

gen x=rnormal()

rms x if x>0

di r(rms)

 

=={{header|Swift}}==

 

@inlinable

public func rms() -> Element {

}

 

 

{{out}}

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

set sum 0.0

foreach value $list { set sum [expr {$sum + $value**2}] }

}

 

{{out}}

<pre>

=={{header|Ursala}}==

using the <code>mean</code> function among others from the <code>flo</code> library

#import flo

 

#cast %e

 

{{out}}

<pre>

=={{header|Vala}}==

Valac probably needs to have the flag "-X -lm" added to include the C Math library.

double sum_squares = 0;

double mean;

stdout.printf("%s\n", mean.to_string());

{{out}}

<pre>

=={{header|VBA}}==

Using Excel VBA

For i = 1 To UBound(s)

s(i) = s(i) ^ 2

s = [{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}]

Debug.Print root_mean_square(s)

Without using Excel worksheetfunction:

Dim i As Integer

If iLow > iHigh Then

Debug.Print rms(1, 10)

End Sub

 

Output:

 

=={{header|Vlang}}==

fn main() {

}

println(math.sqrt(sum / n))

 

{{out}}

 

=={{header|Wortel}}==

; using a composition and a fork (like you would do in J)

rms1 ^(@sqrt @(@sum / #) *^@sq)

!rms2 @to 10

]]

{{out}}

<pre>[6.2048368229954285 6.2048368229954285]</pre>

 

=={{header|Wren}}==

 

{{out}}

 

=={{header|XLISP}}==

(sqrt

(/

; test QUADRATIC-MEAN

 

{{out}}

<pre>6.20483682299543</pre>

 

=={{header|XPL0}}==

code real RlOut=48;

int N;

RlOut(0, sqrt(S/10.0));

CrLf(0);

{{out}}

<pre>

 

=={{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>