# Averages/Root mean square

Averages/Root mean square
You are encouraged to solve this task according to the task description, using any language you may know.

Compute the   Root mean square   of the numbers 1..10.

The   root mean square   is also known by its initials RMS (or rms), and as the quadratic mean.

The RMS is calculated as the mean of the squares of the numbers, square-rooted:

${\displaystyle x_{\mathrm {rms} }={\sqrt {{{x_{1}}^{2}+{x_{2}}^{2}+\cdots +{x_{n}}^{2}} \over n}}.}$

## 11l

Translation of: Python
F qmean(num)   R sqrt(sum(num.map(n -> n * n)) / Float(num.len)) print(qmean(1..10))
Output:
6.20484


with Ada.Float_Text_IO; use Ada.Float_Text_IO;with Ada.Numerics.Elementary_Functions;use Ada.Numerics.Elementary_Functions;procedure calcrms is	type float_arr is array(1..10) of Float; 	function rms(nums : float_arr) return Float is		sum : Float := 0.0;		begin		for p in nums'Range loop			sum := sum + nums(p)**2;		end loop;		return sqrt(sum/Float(nums'Length));	end rms; 	list : float_arr;beginlist := (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;
Output:
 6.20484


## ALGOL 68

Works with: ALGOL 68 version Standard - no extensions to language used
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny
Works with: ELLA ALGOL 68 version Any (with appropriate job cards)
# Define the rms PROCedure & ABS OPerators for LONG... REAL #MODE RMSFIELD = #LONG...# REAL;PROC (RMSFIELD)RMSFIELD rms field sqrt = #long...# sqrt;INT rms field width = #long...# real width; PROC crude rms = ([]RMSFIELD v)RMSFIELD: (  RMSFIELD sum := 0;  FOR i FROM LWB v TO UPB v DO sum +:= v[i]**2 OD;  rms field sqrt(sum / (UPB v - LWB v + 1))); PROC rms = ([]RMSFIELD v)RMSFIELD: (# round off error accumulated at standard precision #  RMSFIELD sum := 0, round off error:= 0;  FOR i FROM LWB v TO UPB v DO     RMSFIELD org = sum, prod = v[i]**2;    sum +:= prod;    round off error +:= sum - org - prod  OD;  rms field sqrt((sum - round off error)/(UPB v - LWB v + 1))); main: (  []RMSFIELD one to ten = (1,2,3,4,5,6,7,8,9,10);   print(("crude rms(one to ten): ", crude rms(one to ten), new line));  print(("rms(one to ten): ",       rms(one to ten), new line)))
Output:
crude rms(one to ten): +6.20483682299543e  +0
rms(one to ten): +6.20483682299543e  +0


## ALGOL W

begin    % computes the root-mean-square of an array of numbers with               %    % the specified lower bound (lb) and upper bound (ub)                     %    real procedure rms( real    array numbers ( * )                      ; integer value lb                      ; integer value ub                      ) ;        begin            real sum;            sum := 0;            for i := lb until ub do sum := sum + ( numbers(i) * numbers(i) );            sqrt( sum / ( ( ub - lb ) + 1 ) )        end rms ;     % test the rms procedure with the numbers 1 to 10                         %    real array testNumbers( 1 :: 10 );    for i := 1 until 10 do testNumbers(i) := i;    r_format := "A"; r_w := 10; r_d := 4; % set fixed point output           %    write( "rms of 1 .. 10: ", rms( testNumbers, 1, 10 ) ); end.
Output:
rms of 1 .. 10:     6.2048


## APL

 rms←{((+/⍵*2)÷⍴⍵)*0.5} x←⍳10  rms x6.204836823

## AppleScript

Translation of: JavaScript
( ES6 version )
-- rootMeanSquare :: [Num] -> Realon 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.204836822995end run  -- GENERIC FUNCTIONS ---------------------------------------------------------- -- foldl :: (a -> b -> a) -> a -> [b] -> aon 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 tellend foldl -- Lift 2nd class handler function into 1st class script wrapper -- mReturn :: Handler -> Scripton mReturn(f)    if class of f is script then        f    else        script            property |λ| : f        end script    end ifend mReturn
Output:
6.204836822995

## Astro

sqrt(mean(x²))

## AutoHotkey

### Using a loop

MsgBox, % RMS(1, 10)  ;---------------------------------------------------------------------------RMS(a, b) { ; Root Mean Square of integers a through b;---------------------------------------------------------------------------    n := b - a + 1    Loop, %n%        Sum += (a + A_Index - 1) ** 2    Return, Sqrt(Sum / n)}

Message box shows:

6.204837


### Avoiding a loop

Using these equations:
${\displaystyle \sum _{i=1}^{n}i^{2}={\frac {n(n+1)(2n+1)}{6}}}$ See wp:List of mathematical series

for ${\displaystyle a : ${\displaystyle \sum _{i=a}^{b}i^{2}=\sum _{i=1}^{b}i^{2}-\sum _{i=1}^{a-1}i^{2}}$

We can show that:
${\displaystyle \sum _{i=a}^{b}i^{2}={\frac {b(b+1)(2b+1)-a(a-1)(2a-1)}{6}}}$

MsgBox, % RMS(1, 10)  ;---------------------------------------------------------------------------RMS(a, b) { ; Root Mean Square of integers a through b;---------------------------------------------------------------------------    Return, Sqrt((b*(b+1)*(2*b+1)-a*(a-1)*(2*a-1))/6/(b-a+1))}

Message box shows:

6.204837


#!/usr/bin/awk -f# computes RMS of the 1st column of a data file{    x  = $1; # value of 1st column S += x*x; N++;} END { print "RMS: ",sqrt(S/N);} ## BASIC Works with: QBasic Note that this will work in Visual Basic and the Windows versions of PowerBASIC by simply wrapping the module-level code into the MAIN function, and changing PRINT to MSGBOX. DIM i(1 TO 10) AS DOUBLE, L0 AS LONGFOR L0 = 1 TO 10 i(L0) = L0NEXTPRINT STR$(rms#(i())) FUNCTION rms# (what() AS DOUBLE)    DIM L0 AS LONG, tmp AS DOUBLE, rt AS DOUBLE    FOR L0 = LBOUND(what) TO UBOUND(what)        rt = rt + (what(L0) ^ 2)    NEXT    tmp = UBOUND(what) - LBOUND(what) + 1    rms# = SQR(rt / tmp)END FUNCTION

### Applesoft BASIC

 10 N = 10 20  FOR I = 1 TO N 30 S = S + I * I 40  NEXT 50 X =  SQR (S / N) 60  PRINT X
Output:
6.20483683

### IS-BASIC

100 PRINT RMS(10)110 DEF RMS(N)120   LET R=0130   FOR X=1 TO N140     LET R=R+X^2150   NEXT160   LET RMS=SQR(R/N)170 END DEF

### Sinclair ZX81 BASIC

10 FAST20 LET RMS=030 FOR X=1 TO 1040 LET RMS=RMS+X**250 NEXT X60 LET RMS=SQR (RMS/10)70 SLOW80 PRINT RMS
Output:
6.2048368

### BBC BASIC

      DIM array(9)      array() = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10       PRINT FNrms(array())      END       DEF FNrms(a()) = MOD(a()) / SQR(DIM(a(),1)+1)

## C

#include <stdio.h>#include <math.h> double rms(double *v, int n){  int i;  double sum = 0.0;  for(i = 0; i < n; i++)    sum += v[i] * v[i];  return sqrt(sum / n);} int main(void){  double v[] = {1., 2., 3., 4., 5., 6., 7., 8., 9., 10.};  printf("%f\n", rms(v, sizeof(v)/sizeof(double)));  return 0;}

## C#

using System; namespace rms{    class Program    {        static void Main(string[] args)        {            int[] x = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };            Console.WriteLine(rootMeanSquare(x));        }         private static double rootMeanSquare(int[] x)        {                        double sum = 0;            for (int i = 0; i < x.Length; i++)            {                sum += (x[i]*x[i]);            }            return Math.Sqrt(sum / x.Length);        }    }}

An alternative method demonstrating the more functional style introduced by LINQ and lambda expressions in C# 3.

Works with: C# version 3
using System;using System.Collections.Generic;using System.Linq; namespace rms{    class Program    {        static void Main(string[] args)        {            Console.WriteLine(rootMeanSquare(Enumerable.Range(1, 10)));        }         private static double rootMeanSquare(IEnumerable<int> x)        {            return Math.Sqrt((double)x.Sum(n => n * n) / x.Count());        }    }}

## C++

#include <iostream>#include <vector>#include <cmath>#include <numeric> int main( ) {  std::vector<int> numbers ;  for ( int i = 1 ; i < 11 ; i++ )    numbers.push_back( i ) ;  double meansquare = sqrt( ( std::inner_product( numbers.begin(), numbers.end(), numbers.begin(), 0 ) ) / static_cast<double>( numbers.size() ) );  std::cout << "The quadratic mean of the numbers 1 .. " << numbers.size() << " is " << meansquare << " !\n" ;  return 0 ;}
Output:
The quadratic mean of the numbers 1 .. 10 is 6.20484 !


## Clojure

 (defn rms [xs]  (Math/sqrt (/ (reduce + (map #(* % %) xs))	   (count xs)))) (println (rms (range 1 11)))
Output:
6.2048368229954285


## COBOL

Could be written more succinctly, with an inline loop and more COMPUTE statements; but that wouldn't be very COBOLic.

IDENTIFICATION DIVISION.PROGRAM-ID. QUADRATIC-MEAN-PROGRAM.DATA DIVISION.WORKING-STORAGE SECTION.01  QUADRATIC-MEAN-VARS.    05 N               PIC 99        VALUE 0.    05 N-SQUARED       PIC 999.    05 RUNNING-TOTAL   PIC 999       VALUE 0.    05 MEAN-OF-SQUARES PIC 99V9(16).    05 QUADRATIC-MEAN  PIC 9V9(15).PROCEDURE DIVISION.CONTROL-PARAGRAPH.    PERFORM MULTIPLICATION-PARAGRAPH 10 TIMES.    DIVIDE  RUNNING-TOTAL BY 10 GIVING MEAN-OF-SQUARES.    COMPUTE QUADRATIC-MEAN = FUNCTION SQRT(MEAN-OF-SQUARES).    DISPLAY QUADRATIC-MEAN UPON CONSOLE.    STOP RUN.MULTIPLICATION-PARAGRAPH.    ADD      1         TO N.    MULTIPLY N         BY N GIVING N-SQUARED.    ADD      N-SQUARED TO RUNNING-TOTAL.
Output:
6.204836822995428

## CoffeeScript

Translation of: JavaScript
    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])

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

Here's a non-iterative solution.

 (defun root-mean-square (numbers)  "Takes a list of numbers, returns their quadratic mean."  (sqrt   (/ (apply #'+ (mapcar #'(lambda (x) (* x x)) numbers))      (length numbers)))) (root-mean-square (loop for i from 1 to 10 collect i))

## Crystal

Translation of: Ruby
def rms(seq)  Math.sqrt(seq.reduce(0.0) {|sum, x| sum + x*x} / seq.size)end puts rms (1..10).to_a
Output:
6.2048368229954285


## D

import std.stdio, std.math, std.algorithm, std.range; real rms(R)(R d) pure {    return sqrt(d.reduce!((a, b) => a + b * b) / real(d.length));} void main() {    writefln("%.19f", iota(1, 11).rms);}
Output:
6.2048368229954282979


## 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 [email protected] 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 ${\displaystyle 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 DoubleFor i As Integer = 1 To 10  vector(i) = iNext Print "Quadratic mean (or RMS) is :"; QuadraticMean(vector())PrintPrint "Press any key to quit the program"Sleep 
Output:
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))}
Output:
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..10def Q = quadMean(list)println """list: ${list} Q:${Q}"""
Output:
list: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Q: 6.2048368229954285

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] -> DoublerootMeanSquare = sqrt . (((/) . foldr ((+) . (^ 2)) 0) <*> genericLength) main :: IO ()main = print$ rootMeanSquare [1 .. 10]
Output:
6.2048368229954285

## HicEst

sum = 0DO i = 1, 10   sum = sum + i^2ENDDOWRITE(ClipBoard) "RMS(1..10) = ", (sum/10)^0.5 

RMS(1..10) = 6.204836823

## Icon and 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. 106.20484

*: means square

(+/ % #) is an idiom for mean.

&.: means 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 &. 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));    }}
Output:
The RMS of the numbers from 1 to 10 is 6.2048368229954285

## JavaScript

### ES5

Works with: JavaScript version 1.8
Works with: Firefox version 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})();
Output:
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: rms ## Julia There are a variety of ways to do this via built-in functions in Julia, given an array A = [1:10] of values. The formula can be implemented directly as: sqrt(sum(A.^2.) / length(A)) or shorter (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+!106.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)}")}
Output:
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)
Output:
6.204837

## NetRexx

/* NetRexx */options replace format comments java crossref symbols nobinary parse arg maxV .if maxV = '' | maxV = '.' then maxV = 10 sum = 0loop nr = 1 for maxV  sum = sum + nr ** 2  end nrrmsD = Math.sqrt(sum / maxV) say 'RMS of values from 1 to' maxV':' rmsD return 
Output:
RMS of values from 1 to 10: 6.204836822995428


## Nim

from math import sqrt, sumfrom 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])
Output:
6.2048368229954285e+00

## 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.LnEND QM. 
Output:
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 .
Output:
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
Output:
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}}}  endin   {Show {RMS {List.number 1 10 1}}}
Output:
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 version 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})
Output:
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)); 
Output:
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 ) ) )
Output:
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;
Output:
RMS= 6.20483682299543E+0000;

## PostScript

/findrms{/x exch def/sum 0 def/i 0 defx 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}ifelsesum ==}def [1 2 3 4 5 6 7 8 9 10] findrms
Output:
6.20483685

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

## Powerbuilder

long ll_x, ll_y, ll_productdecimal ld_rms ll_x = 1ll_y = 10DO WHILE ll_x <= ll_y	ll_product += ll_x * ll_x	ll_x ++LOOPld_rms = Sqrt(ll_product / ll_y) //ld_rms value is 6.20483682299542849

## Shen

Works with: shen-scheme version 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 }
Output:
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
Output:
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)));
Output:
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

clearset obs 20gen x=rnormal() rms xdi r(rms)1.0394189 rms x if x>0di r(rms).7423647

## Tcl

Works with: Tcl version 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}]"
Output:
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)
Output:
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());}
Output:
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 FunctionPublic 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  ]]}
Output:
[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)))
Output:
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);]
Output:
    6.20484


## Yacas

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

The above will give the precise solution ${\displaystyle {\sqrt {\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