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


## Euphoria


```euphoria
function rms(sequence s)
    atom sum
    if length(s) = 0 then
        return 0
    end if
    sum = 0
    for i = 1 to length(s) do
        sum += power(s[i],2)
    end for
    return sqrt(sum/length(s))
end function

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

{{out}}

6.204836823

Excel

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)

=={{header|F Sharp|F#}}== Uses a lambda expression and function piping.

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]

Answer (in F# Interactive window):

val res : float = 6.204836823

Fantom

class Main
{
  static Float averageRms (Float[] nums)
  {
    if (nums.size == 0) return 0.0f
    Float sum := 0f
    nums.each { sum += it * it }
    return (sum / nums.size.toFloat).sqrt
  }

  public static Void main ()
  {
    a := [1f,2f,3f,4f,5f,6f,7f,8f,9f,10f]
    echo ("RMS Average of $a is: " + averageRms(a))
  }
}

Factor

: root-mean-square ( seq -- mean )
    [ [ sq ] map-sum ] [ length ] bi / sqrt ;

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

Forth

: rms ( faddr len -- frms )
  dup >r 0e
  floats bounds do
    i f@ fdup f* f+
  float +loop
  r> s>f f/ fsqrt ;

create test 1e f, 2e f, 3e f, 4e f, 5e f, 6e f, 7e f, 8e f, 9e f, 10e f,
test 10 rms f.    \ 6.20483682299543

Fortran

Assume $x$ stored in array x.

print *,sqrt( sum(x**2)/size(x) )

FreeBASIC

' FB 1.05.0 Win64

Function QuadraticMean(array() As Double) As Double
  Dim length As Integer = Ubound(array) - Lbound(array) + 1
  Dim As Double sum = 0.0
  For i As Integer = LBound(array) To UBound(array)
    sum += array(i) * array(i)
  Next
  Return Sqr(sum/length)
End Function

Dim vector(1 To 10) As Double
For i As Integer = 1 To 10
  vector(i) = i
Next

Print "Quadratic mean (or RMS) is :"; QuadraticMean(vector())
Print
Print "Press any key to quit the program"
Sleep

{{out}}

Quadratic mean (or RMS) is : 6.204836822995429

Futhark

import "futlib/math"

fun main(as: [n]f64): f64 =
  f64.sqrt ((reduce (+) 0.0 (map (**2.0) as)) / f64(n))

GEORGE

1, 10 rep (i)
   i i | (v) ;
0
 1, 10 rep (i)
   i dup mult +
   ]
10 div
 sqrt
 print

 6.204836822995428

Go

package main

import (
    "fmt"
    "math"
)

func main() {
    const n = 10
    sum := 0.
    for x := 1.; x <= n; x++ {
        sum += x * x
    }
    fmt.Println(math.Sqrt(sum / n))
}

{{out}}

6.2048368229954285

Groovy

Solution:

def quadMean = { list ->
    list == null \
        ? null \
        : list.empty \
            ? 0 \
            : ((list.collect { it*it }.sum()) / list.size()) ** 0.5
}

Test:

def list = 1..10
def Q = quadMean(list)
println """
list: ${list}
   Q: ${Q}
"""

{{out}}

list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   Q: 6.2048368229954285

Haskell

Given the mean function defined in [[Averages/Pythagorean means]]:

main = print $ mean 2 [1 .. 10]

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

import Data.List (genericLength)

rootMeanSquare :: [Double] -> Double
rootMeanSquare = sqrt . (((/) . foldr ((+) . (^ 2)) 0) <*> genericLength)

main :: IO ()
main = print $ rootMeanSquare [1 .. 10]

{{Out}}

6.2048368229954285

HicEst

sum = 0
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}}==

procedure main()
every put(x := [], 1 to 10)
writes("x := [ "); every writes(!x," "); write("]")
write("Quadratic mean:",q := qmean!x)
end

procedure qmean(L[])             #: quadratic mean
   local m
   if *L = 0 then fail
   every (m := 0.0) +:= !L^2
   return sqrt(m / *L)
end

Io

rms := method (figs, (figs map(** 2) reduce(+) / figs size) sqrt)

rms( Range 1 to(10) asList ) println

J

'''Solution:'''

rms=: (+/ % #)&.:*:

'''Example Usage:'''

  rms 1 + i. 10
6.20484

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

(+/ % #) is an idiom for [[../Arithmetic_mean#J|mean]].

&.: means [http://jsoftware.com/help/dictionary/d631c.htm under] -- in other words, we square numbers, take their average and then use the inverse of square on the result. (see also the page on [http://jsoftware.com/help/dictionary/d631.htm &.] which does basically the same thing but with different granularity -- item at a time instead of everything at once.

Java

public class RootMeanSquare {

    public static double rootMeanSquare(double... nums) {
        double sum = 0.0;
        for (double num : nums)
            sum += num * num;
        return Math.sqrt(sum / 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 " + rootMeanSquare(nums));
    }
}

{{out}}

The RMS of the numbers from 1 to 10 is 6.2048368229954285

JavaScript

ES5

{{works with|JavaScript|1.8}} {{works with|Firefox|3.0}}

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

ES6

(() => {
    'use strict';


    // rootMeanSquare :: [Num] -> Real
    const rootMeanSquare = xs =>
       Math.sqrt(
            xs.reduce(
                (a, x) => (a + x * x),
                0
           ) / xs.length
        );


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

     // -> 6.2048368229954285
})();

{{Out}}

6.2048368229954285

jq

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

def rms: length as $length
  | if $length == 0 then null
    else map(. * .) | add | sqrt / $length
    end ;

With this definition, the following program would compute the rms of each array in a file or stream of numeric arrays:

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

```julia
sqrt(sum(A.^2.) / length(A))

or shorter with using Statistics (and as spoken: root-mean-square)

sqrt(mean(A.^2.))

or the implicit allocation of a new array by A.^2. can be avoided by using sum as a higher-order function:

sqrt(sum(x -> x*x, A) / length(A))

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

function rms(A)
   s = 0.0
   for a in A
      s += a*a
   end
   return sqrt(s / length(A))
end

Potentially even better is to use the built-in norm function, which computes the square root of the sum of the squares of the entries of A in a way that avoids the possibility of spurious floating-point overflow (if the entries of A are so large that they may overflow if squared):

norm(A) / sqrt(length(A))

K

  rms:{_sqrt (+/x^2)%#x}
  rms 1+!10
6.204837

Kotlin

// 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)}")
}

{{out}}

Quadratic mean of numbers 1 to 10 is 6.2048368229954285

Lasso

define rms(a::staticarray)::decimal => {
	return math_sqrt((with n in #a sum #n*#n) / decimal(#a->size))
}
rms(generateSeries(1,10)->asStaticArray)

{{out}}

6.204837

Liberty BASIC

'   [RC] Averages/Root mean square

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

    '   If saved as an array we'd have to have a flag for last data.
    '   LB has the very useful word$() to read from delimited strings.
    '   The default delimiter is a space character, " ".

    SumOfSquares    =0
    n               =0      '   This holds index to number, and counts number of data.
    data$           ="666"  '   temporary dummy to enter the loop.

    while data$ <>""                                '   we loop until no data left.
        data$           =word$( SourceList$, n +1)  '   first data, as a string
        NewVal          =val( data$)                '   convert string to number
        SumOfSquares    =SumOfSquares +NewVal^2     '   add to existing sum of squares
        n =n +1                                     '   increment number of data items found
    wend

    n =n -1

    print "Supplied data was ";         SourceList$
    print "This contained ";            n; " numbers."
    print "R.M.S. value is ";           ( SumOfSquares /n)^0.5

    end

Logo

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

show rms iseq 1 10

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

Maple

y := [ seq(1..10) ]:
RMS := proc( x )
    return sqrt( Statistics:-Mean( x ^~ 2 ) );
end proc:
RMS( y );

{{out}}

6.20483682299543

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

RootMeanSquare@Range[10]

The above will give the precise solution $\backslash sqrt\{\backslash frac\{77\}\{2\}\}$, to downgrade to 6.20484, use '10.' to imply asking for numeric solution, or append '//N' after the whole expression.

MATLAB

function rms = quadraticMean(list)
    rms = sqrt(mean(list.^2));
end

Solution:

 quadraticMean((1:10))

ans =

   6.204836822995429

Maxima

L: makelist(i, i, 10)$

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

rms(L), numer;   /* 6.204836822995429 */

MAXScript

fn RMS arr =
(
	local sumSquared = 0
	for i in arr do sumSquared += i^2
	return (sqrt (sumSquared/arr.count as float))
)

Output:

rms #{1..10}
6.20484

=={{header|МК-61/52}}== 0 П0 П1 С/П x^2 ИП0 x^2 ИП1 * + ИП1 1 + П1 / КвКор П0 БП 03

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

Each time you press the С/П on the indicator would mean already entered numbers.


## Morfa

{{trans|D}}

```morfa

import morfa.base;
import morfa.functional.base;

template <TRange>
func rms(d: TRange): float
{
    var count = 1;
    return sqrt(reduce( (a: float, b: float) { count += 1; return a + b * b; }, d) / count);
}

func main(): void
{
    println(rms(1 .. 11));
}

{{out}}

6.204837

Nemerle

using System;
using System.Console;
using System.Math;

module RMS
{
    RMS(x : list[int]) : double
    {
        def sum = x.Map(fun (x) {x*x}).FoldLeft(0, _+_);
        Sqrt((sum :> double) / x.Length)
    }

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

NetRexx

/* NetRexx */
options replace format comments java crossref symbols nobinary

parse arg maxV .
if maxV = '' | maxV = '.' then maxV = 10

sum = 0
loop nr = 1 for maxV
  sum = sum + nr ** 2
  end nr
rmsD = Math.sqrt(sum / maxV)

say 'RMS of values from 1 to' maxV':' rmsD

return

{{out}}

RMS of values from 1 to 10: 6.204836822995428

Nim

from math import sqrt, sum
from sequtils import mapIt

proc qmean(num: seq[float]): float =
  result = num.mapIt(it * 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])

{{out}}

6.2048368229954285e+00

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

MODULE QM;
IMPORT ML := MathL, Out;
VAR
	nums: ARRAY 10 OF LONGREAL;
	i: INTEGER;

PROCEDURE Rms(a: ARRAY OF LONGREAL): LONGREAL;
VAR
	i: INTEGER;
	s: LONGREAL;
BEGIN
	s := 0.0;
	FOR i := 0 TO LEN(a) - 1 DO
		s := s + (a[i] * a[i])
	END;
	RETURN ML.Sqrt(s / LEN(a))
END Rms;

BEGIN
	FOR i := 0 TO LEN(nums) - 1 DO
		nums[i] := i + 1
	END;
	Out.String("Quadratic Mean: ");Out.LongReal(Rms(nums));Out.Ln
END QM.

{{out}}

Quadratic Mean: 6.20483682300

Objeck

bundle Default {
  class Hello {
    function : Main(args : String[]) ~ Nil {
      values := [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0];
      RootSquareMean(values)->PrintLine();
    }

    function : native : RootSquareMean(values : Float[]) ~ Float {
      sum := 0.0;
      each(i : values) {
        x := values[i]->Power(2.0);
        sum += values[i]->Power(2.0);
      };

      return (sum / values->Size())->SquareRoot();
    }
  }
}

OCaml

let rms a =
  sqrt (Array.fold_left (fun s x -> s +. x*.x) 0.0 a /.
        float_of_int (Array.length a))
;;

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

Oforth

10 seq map(#sq) sum 10.0 / sqrt .

{{out}}

6.20483682299543

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)

::routine testAverage
  use arg list
  say "list =" list~toString("l", ", ")
  say "root mean square =" rootmeansquare(list)
  say

::routine rootmeansquare
  use arg numbers
  -- return zero for an empty list
  if numbers~isempty then return 0

  sum = 0
  do number over numbers
      sum += number * number
  end
  return rxcalcsqrt(sum/numbers~items)

::requires rxmath LIBRARY

{{out}}

list = 10, 9, 8, 7, 6, 5, 4, 3, 2, 1
root mean square = 6.20483682

list = 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, .11
root mean square = 5.06630766

list = 30, 10, 20, 30, 40, 50, -100, 4.7, -1100
root mean square = 369.146476

Oz

declare
  fun {Square X} X*X end

  fun {RMS Xs}
     {Sqrt
      {Int.toFloat {FoldL {Map Xs Square} Number.'+' 0}}
      /
      {Int.toFloat {Length Xs}}}
  end
in
  {Show {RMS {List.number 1 10 1}}}

{{out}}

6.2048

PARI/GP

General RMS calculation:

RMS(v)={
  sqrt(sum(i=1,#v,v[i]^2)/#v)
};

RMS(vector(10,i,i))

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

RMS_first(n)={
  sqrt((n+1)*(2*n+1)/6)
};

RMS_first(10)

Asymptotically this is n/sqrt(3).

Perl

use v5.10.0;
sub rms
{
        my $r = 0;
        $r += $_**2 for @_;
        sqrt( $r/@_ );
}

say rms(1..10);

Perl 6

{{works with|Rakudo|2015.12}}

sub rms(*@nums) { sqrt [+](@nums X** 2) / @nums }

say rms 1..10;

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

sub rms { sqrt @_ R/ [+] @_ X** 2 }

Phix

function rms(sequence s)
atom sqsum = 0
    for i=1 to length(s) do
        sqsum += power(s[i],2)
    end for
    return sqrt(sqsum/length(s))
end function

? rms({1,2,3,4,5,6,7,8,9,10})

{{out}}

6.204836823

PHP

<?php
// Created with PHP 7.0

function rms(array $numbers)
{
    $sum = 0;

    foreach ($numbers as $number) {
        $sum += $number**2;
    }

    return sqrt($sum / count($numbers));
}

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

{{out}}

6.2048368229954

PicoLisp

(scl 5)

(let Lst (1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0)
   (prinl
      (format
         (sqrt
            (*/
               (sum '((N) (*/ N N 1.0)) Lst)
               1.0
               (length Lst) )
            T )
         *Scl ) ) )

{{out}}

6.20484

PL/I

 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);
 n = hbound(A,1);
 RMS = sqrt(sum(A**2)/n);
 put Skip Data(rms);
 End;

{{out}}

RMS= 6.20483682299543E+0000;

PostScript

/findrms{
/x exch def
/sum 0 def
/i 0 def
x length 0 eq{}
{
x length{
/sum x i get 2 exp sum add def
/i i 1 add def
}repeat
/sum sum x length div sqrt def
}ifelse
sum ==
}def

[1 2 3 4 5 6 7 8 9 10] findrms

{{out}}

6.20483685

{{libheader|initlib}}

[1 10] 1 range dup 0 {dup * +} fold exch length div sqrt

Powerbuilder

long ll_x, ll_y, ll_product
decimal ld_rms

ll_x = 1
ll_y = 10
DO WHILE ll_x <= ll_y
	ll_product += ll_x * ll_x
	ll_x ++
LOOP
ld_rms = Sqrt(ll_product / ll_y)

//ld_rms value is 6.20483682299542849

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)

PureBasic

NewList MyList()  ; To hold a unknown amount of numbers to calculate

If OpenConsole()
  Define.d result
  Define i, sum_of_squares

  ;Populate a random amounts of numbers to calculate
  For i=0 To (Random(45)+5) ; max elements is unknown to the program
    AddElement(MyList())
    MyList()=Random(15)  ; Put in a random number
  Next

  Print("Averages/Root mean square"+#CRLF$+"of : ")

  ; Calculate square of each element, print each & add them together
  ForEach MyList()
    Print(Str(MyList())+" ")             ; Present to our user
    sum_of_squares+MyList()*MyList()     ; Sum the squares, e.g
  Next

  ;Present the result
  result=Sqr(sum_of_squares/ListSize(MyList()))
  PrintN(#CRLF$+"= "+StrD(result))

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

Python

{{works with|Python|3}}

 from math import sqrt
>>> def qmean(num):
	return sqrt(sum(n*n for n in num)/len(num))

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

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.

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 from future import division, 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''':

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

{{Out}}

6.2048368229954285

Qi

(define rms
  R -> (sqrt (/ (APPLY + (MAPCAR * R R)) (length R))))

R

We may calculate the answer directly using R's built-in sqrt and mean functions:

sqrt(mean((1:10)^2))

The following function works for any vector x:

RMS = function(x){
 sqrt(mean(x^2))
}

Usage:

 RMS(1:10)
[1] 6.204837

Racket

#lang racket
(define (rms nums)
  (sqrt (/ (for/sum ([n nums]) (* n n)) (length nums))))

REXX

REXX has no built-in '''sqrt''' function, so a RYO version is included here.

This particular '''sqrt''' function was programmed for speed, as it has two critical components: :::* the initial guess (for the square root) :::* the number of (increasing) decimal digits used during the computations

The '''sqrt''' code was optimized to use the minimum amount of digits (precision) for each iteration of the

calculation as well as a reasonable attempt at providing a first-guess square root by essentially halving

the number using logarithmic (base ten) arithmetic.

/*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.*/
if digs==''  |  digs==","  then digs=50          /* "      "         "   "   "     "    */
if show==''  |  show==","  then show=10          /* "      "         "   "   "     "    */
numeric digits digs                              /*uses  DIGS  decimal digits for calc. */
$=0;                     do j=1  for nums        /*process each of the   N   integers.  */
                         $=$ + j**2              /*sum the   squares   of the integers. */
                         end   /*j*/
                                                 /* [↓]  displays  SHOW  decimal digits.*/
rms=format( sqrt($/nums), , show ) / 1           /*divide by N, then calculate the SQRT.*/
say 'root mean square for 1──►'nums  "is: "  rms /*display the  root mean square (RMS). */
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
sqrt:  procedure; parse arg x;  if x=0  then return 0;  d=digits();  numeric digits;  m.=9
       numeric form;  parse value format(x,2,1,,0) 'E0'  with  g 'E' _ .;  g=g *.5'e'_ % 2
       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:

root mean square for 1──►10 is:  6.204836823

Ring

nums = [1,2,3,4,5,6,7,8,9,10]
sum = 0
decimals(5)
see "Average = " + average(nums) + nl

func average number
     for i = 1 to len(number)
         sum = sum + pow(number[i],2)
     next
     x = sqrt(sum / len(number))
     return x

Ruby

class Array
  def quadratic_mean
    Math.sqrt( self.inject(0.0) {|s, y| s + y*y} / self.length )
  end
end

class Range
  def quadratic_mean
    self.to_a.quadratic_mean
  end
end

(1..10).quadratic_mean  # => 6.2048368229954285

and a non object-oriented solution:

def rms(seq)
  Math.sqrt(seq.inject(0.0) {|sum, x| sum + x*x} / seq.length)
end
puts rms (1..10).to_a   # => 6.2048368229954285

Run BASIC

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
  sumSquares = sumSquares + thisValue ^ 2      ' sum up the squares
  i = i +1                                     '
wend
print "List of Values:";valueList$;" containing ";i;" values"
print "Root Mean Square =";(sumSquares/i)^0.5

{{out}} List of Values:1 2 3 4 5 6 7 8 9 10 containing 10 values Root Mean Square =6.20483682

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

fn main() {
    let vec = (1..11).collect();
    println!("The root mean square is: {}", root_mean_square(vec));
}

{{out}} The root mean square is: 6.204837

=={{header|S-lang}}== Many of math operations in S-Lang are 'vectorized', that is, given an array, they apply themselves to each element. In this case, that means no array_map() function needed. Also, "range arrays" have a built-in syntax.

define rms(arr) { return sqrt(sum(sqr(arr)) / length(arr)); }

print(rms([1:10]));

## Sather


```sather
class MAIN is
  -- irrms stands for Integer Ranged RMS
  irrms(i, f:INT):FLT
    pre i <= f
  is
    sum ::= 0;
    loop
      sum := sum + i.upto!(f).pow(2);
    end;
    return (sum.flt / (f-i+1).flt).sqrt;
  end;

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

Scala

def rms(nums: Seq[Int]) = math.sqrt(nums.map(math.pow(_, 2)).sum / nums.size)
println(rms(1 to 10))

{{out}}

6.2048368229954285

Scheme

(define (rms nums)
  (sqrt (/ (apply + (map * nums nums))
           (length nums))))

(rms '(1 2 3 4 5 6 7 8 9 10))

{{out}}

6.20483682299543

Seed7

$ include "seed7_05.s7i";
  include "float.s7i";
  include "math.s7i";

const array float: numbers is [] (1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0);

const func float: rms (in array float: numbers) is func
  result
    var float: rms is 0.0;
  local
    var float: number is 0.0;
    var float: sum is 0.0;
  begin
    for number range numbers do
      sum +:= number ** 2;
    end for;
    rms := sqrt(sum / flt(length(numbers)));
  end func;

const proc: main is func
  begin
    writeln(rms(numbers) digits 7);
  end func;

Shen

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

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

Sidef

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

say rms(1..10)

Using hyper operators, we can write it as:

func rms(a) { a »**» 2 «+» / a.len -> sqrt }

{{out}}

6.20483682299542829806662097772473784992796529536

Smalltalk

(((1 to: 10) inject: 0 into: [ :s :n | n*n + s ]) / 10) sqrt.

SNOBOL4

{{works with|Macro Spitbol}} {{works with|CSnobol}} There is no built-in sqrt( ) function in 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)
rms_end

*       # Fill array, test and display
        str = '1 2 3 4 5 6 7 8 9 10'; a = array(10)
loop    i = i + 1; str len(p) span('0123456789') . a<i> @p :s(loop)
        output = str ' -> ' rms(a)
end

{{out}}

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

Standard ML

fun rms(v: real vector) =
  let
    val v' = Vector.map (fn x => x*x) v
    val sum = Vector.foldl op+ 0.0 v'
  in
    Math.sqrt( sum/real(Vector.length(v')) )
  end;

rms(Vector.tabulate(10, fn n => real(n+1)));

{{out}}

val it = 6.204836823 : real

Stata

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

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

'''Example'''

clear
set obs 20
gen x=rnormal()

rms x
di r(rms)
1.0394189

rms x if x>0
di r(rms)
.7423647

Tcl

{{works with|Tcl|8.5}}

proc qmean list {
    set sum 0.0
    foreach value $list { set sum [expr {$sum + $value**2}] }
    return [expr { sqrt($sum / [llength $list]) }]
}

puts "RMS(1..10) = [qmean {1 2 3 4 5 6 7 8 9 10}]"

{{out}}

RMS(1..10) = 6.2048368229954285

Ursala

using the mean function among others from the flo library

#import nat
#import flo

#cast %e

rms = sqrt mean sqr* float* nrange(1,10)

{{out}}

6.204837e+00

Vala

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

double rms(double[] list){
	double sum_squares = 0;
	double mean;

	foreach ( double number in list){
		sum_squares += (number * number);
	}

	mean = Math.sqrt(sum_squares / (double) list.length);

	return mean;
} // end rms

public static void main(){
	double[] list = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	double mean = rms(list);

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

{{out}}

6.2048368229954285

VBA

Using Excel VBA

Private Function root_mean_square(s() As Variant) As Double
    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

Without using Excel worksheetfunction:

Function rms(iLow As Integer, iHigh As Integer)
    Dim i As Integer
    If iLow > iHigh Then
        i = iLow
        iLow = iHigh
        iHigh = i
    End If
    For i = iLow To iHigh
        rms = rms + i ^ 2
    Next i
    rms = Sqr(rms / (iHigh - iLow + 1))
End Function

Sub foo()
    Debug.Print rms(1, 10)
End Sub

Output:

 6.20483682299543

Wortel

@let {
  ; using a composition and a fork (like you would do in J)
  rms1 ^(@sqrt @(@sum / #) *^@sq)

  ; using a function with a named argument
  rms2 &a @sqrt ~/ #a @sum !*^@sq a

  [[
    !rms1 @to 10
    !rms2 @to 10
  ]]
}

{{out}}

[6.2048368229954285 6.2048368229954285]

XLISP

(defun quadratic-mean (xs)
    (sqrt
        (/
            (apply +
                (mapcar (lambda (x) (expt x 2)) xs))
            (length xs))))

; define a RANGE function, for testing purposes

(defun range (x y)
    (if (< x y)
        (cons x (range (+ x 1) y))))

; test QUADRATIC-MEAN

(print (quadratic-mean (range 1 11)))

{{out}}

6.20483682299543

XPL0

code CrLf=9;
code real RlOut=48;
int  N;
real S;
[S:= 0.0;
for N:= 1 to 10 do S:= S + sq(float(N));
RlOut(0, sqrt(S/10.0));
CrLf(0);
]

{{out}}

    6.20484

Yacas

Sqrt(Add((1 .. 10)^2)/10)

The above will give the precise solution $\backslash sqrt\{\backslash frac\{77\}\{2\}\}$, to downgrade to 6.20483682299, surround the expression with 'N()'.

zkl

fcn rms(z){ ( z.reduce(fcn(p,n){ p + n*n },0.0) /z.len() ).sqrt() }

The order in the reduce function is important as it coerces n*n to float.

zkl: rms([1..10].walk())  //-->rms(T(1,2,3,4,5,6,7,8,9,10))
6.20484