Averages/Root mean square: Difference between revisions
m
Automated syntax highlighting fixup (second round - minor fixes)
SqrtNegInf (talk | contribs) m (→{{header|Raku}}: move paren to a better location) |
Thundergnat (talk | contribs) m (Automated syntax highlighting fixup (second round - minor fixes)) |
||
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}}
<syntaxhighlight lang="11l">F qmean(num)
R sqrt(sum(num.map(n -> n * n)) / Float(num.len))
Line 33:
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<syntaxhighlight lang=
BYTE FUNC Equal(REAL POINTER a,b)
Line 84:
=={{header|Ada}}==
<syntaxhighlight lang=
with Ada.Numerics.Elementary_Functions;
use Ada.Numerics.Elementary_Functions;
Line 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)}}
<syntaxhighlight lang="algol68"># Define the rms PROCedure & ABS OPerators for LONG... REAL #
MODE RMSFIELD = #LONG...# REAL;
PROC (RMSFIELD)RMSFIELD rms field sqrt = #long...# sqrt;
Line 148:
=={{header|ALGOL-M}}==
Because ALGOL-M lacks a built-in square root function, we have to supply our own.
<syntaxhighlight lang="algol">
BEGIN
Line 192:
=={{header|ALGOL W}}==
<syntaxhighlight lang="algolw">begin
% computes the root-mean-square of an array of numbers with %
% the specified lower bound (lb) and upper bound (ub) %
Line 219:
=={{header|APL}}==
<syntaxhighlight lang=
x←⍳10
Line 227:
=={{header|AppleScript}}==
{{Trans|JavaScript}}( ES6 version )
<syntaxhighlight lang=
on rootMeanSquare(xs)
script
Line 278:
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">rootMeanSquare: function [arr]->
sqrt (sum map arr 'i -> i^2) // size arr
Line 288:
=={{header|Astro}}==
<syntaxhighlight lang="python">sqrt(mean(x²))</syntaxhighlight>
=={{header|AutoHotkey}}==
===Using a loop===
<syntaxhighlight lang="autohotkey">MsgBox, % RMS(1, 10)
Line 313:
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>
<syntaxhighlight lang="autohotkey">MsgBox, % RMS(1, 10)
Line 327:
=={{header|AWK}}==
<syntaxhighlight lang="awk">#!/usr/bin/awk -f
# computes RMS of the 1st column of a data file
{
Line 344:
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>.
<syntaxhighlight lang="qbasic">DIM i(1 TO 10) AS DOUBLE, L0 AS LONG
FOR L0 = 1 TO 10
i(L0) = L0
Line 363:
==={{header|Applesoft BASIC}}===
<syntaxhighlight lang=
20 FOR I = 1 TO N
30 S = S + I * I
Line 374:
==={{header|IS-BASIC}}===
<syntaxhighlight lang=
110 DEF RMS(N)
120 LET R=0
Line 384:
==={{header|Sinclair ZX81 BASIC}}===
<syntaxhighlight lang="basic">10 FAST
20 LET RMS=0
30 FOR X=1 TO 10
Line 396:
==={{header|BBC BASIC}}===
<syntaxhighlight lang="bbcbasic"> DIM array(9)
array() = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Line 406:
=={{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}}==
<syntaxhighlight lang="c">#include <stdio.h>
#include <math.h>
Line 437:
=={{header|C sharp|C#}}==
<syntaxhighlight lang="csharp">using System;
namespace rms
Line 462:
An alternative method demonstrating the more functional style introduced by LINQ and lambda expressions in C# 3.
{{works with|C sharp|C#|3}}
<syntaxhighlight lang="csharp">using System;
using System.Collections.Generic;
using System.Linq;
Line 483:
=={{header|C++}}==
<syntaxhighlight lang=
#include <vector>
#include <cmath>
Line 502:
=={{header|Clojure}}==
<syntaxhighlight lang="clojure">
(defn rms [xs]
(Math/sqrt (/ (reduce + (map #(* % %) xs))
Line 515:
=={{header|COBOL}}==
Could be written more succinctly, with an inline loop and more <tt>COMPUTE</tt> statements; but that wouldn't be very COBOLic.
<syntaxhighlight lang="cobol">IDENTIFICATION DIVISION.
PROGRAM-ID. QUADRATIC-MEAN-PROGRAM.
DATA DIVISION.
Line 541:
=={{header|CoffeeScript}}==
{{trans|JavaScript}}
<syntaxhighlight lang="coffeescript"> root_mean_square = (ary) ->
sum_of_squares = ary.reduce ((s,x) -> s + x*x), 0
return Math.sqrt(sum_of_squares / ary.length)
Line 548:
=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">(loop for x from 1 to 10
for xx = (* x x)
for n from 1
Line 556:
Here's a non-iterative solution.
<syntaxhighlight lang="lisp">
(defun root-mean-square (numbers)
"Takes a list of numbers, returns their quadratic mean."
Line 568:
=={{header|Crystal}}==
{{trans|Ruby}}
<syntaxhighlight lang="ruby">def rms(seq)
Math.sqrt(seq.sum { |x| x*x } / seq.size)
end
Line 578:
=={{header|D}}==
<syntaxhighlight lang="d">import std.stdio, std.math, std.algorithm, std.range;
real rms(R)(R d) pure {
Line 593:
=={{header|Delphi}}/{{header|Pascal}}==
<syntaxhighlight lang=
{$APPTYPE CONSOLE}
Line 618:
=={{header|E}}==
Using the same generic mean function as used in [[../Pythagorean means#E|pythagorean means]]:
<syntaxhighlight lang="e">def makeMean(base, include, finish) {
return def mean(numbers) {
var count := 0
Line 632:
def RMS := makeMean(0, fn b,x { b+x**2 }, fn acc,n { (acc/n).sqrt() })</syntaxhighlight>
<syntaxhighlight lang="e">? RMS(1..10)
# value: 6.2048368229954285</syntaxhighlight>
=={{header|EchoLisp}}==
<syntaxhighlight lang="scheme">
(define (rms xs)
(sqrt (// (for/sum ((x xs)) (* x x)) (length xs))))
Line 647:
{{trans|C#}}
ELENA 5.0 :
<syntaxhighlight lang="elena">import extensions;
import system'routines;
import system'math;
Line 667:
=={{header|Elixir}}==
<syntaxhighlight lang="elixir">
defmodule RC do
def root_mean_square(enum) do
Line 699:
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">rms(Nums) ->
math:sqrt(lists:foldl(fun(E,S) -> S+E*E end, 0, Nums) / length(Nums)).
Line 707:
=={{header|ERRE}}==
<syntaxhighlight lang="text">
PROGRAM ROOT_MEAN_SQUARE
BEGIN
Line 721:
=={{header|Euphoria}}==
<syntaxhighlight lang="euphoria">function rms(sequence s)
atom sum
if length(s) = 0 then
Line 741:
===Cell reference expression===
If values are entered in the cells A1 to A10, the below expression will give the RMS value
<syntaxhighlight lang="excel">
=SQRT(SUMSQ($A1:$A10)/COUNT($A1:$A10))
</syntaxhighlight>
Line 755:
{{Works with|Office 365 betas 2021}}
<syntaxhighlight lang="lisp">ROOTMEANSQR
=LAMBDA(xs,
SQRT(SUMSQ(xs)/COUNT(xs))
Line 762:
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,
Line 790:
=={{header|F Sharp|F#}}==
Uses a lambda expression and function piping.
<syntaxhighlight lang=
let res = RMS [1.0..10.0]</syntaxhighlight>
Line 797:
=={{header|Factor}}==
<syntaxhighlight lang="factor">: root-mean-square ( seq -- mean )
[ [ sq ] map-sum ] [ length ] bi / sqrt ;</syntaxhighlight>
Line 804:
=={{header|Fantom}}==
<syntaxhighlight lang="fantom">class Main
{
static Float averageRms (Float[] nums)
Line 822:
=={{header|Forth}}==
<syntaxhighlight lang="forth">: rms ( faddr len -- frms )
dup >r 0e
floats bounds do
Line 834:
=={{header|Fortran}}==
Assume <math> x </math> stored in array x.
<syntaxhighlight lang=
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">
' FB 1.05.0 Win64
Line 867:
=={{header|Futhark}}==
<syntaxhighlight lang=
import "futlib/math"
Line 875:
=={{header|GEORGE}}==
<syntaxhighlight lang=
1, 10 rep (i)
i i | (v) ;
Line 891:
=={{header|Go}}==
<syntaxhighlight lang="go">package main
import (
Line 913:
=={{header|Groovy}}==
Solution:
<syntaxhighlight lang="groovy">def quadMean = { list ->
list == null \
? null \
Line 921:
}</syntaxhighlight>
Test:
<syntaxhighlight lang="groovy">def list = 1..10
def Q = quadMean(list)
println """
Line 933:
=={{header|Haskell}}==
Given the <code>mean</code> function defined in [[Averages/Pythagorean means]]:
<syntaxhighlight lang="haskell">main = print $ mean 2 [1 .. 10]</syntaxhighlight>
Or, writing a naive '''mean''' of our own, (but see https://donsbot.wordpress.com/2008/06/04/haskell-as-fast-as-c-working-at-a-high-altitude-for-low-level-performance/):
<syntaxhighlight lang="haskell">import Data.List (genericLength)
rootMeanSquare :: [Double] -> Double
Line 948:
=={{header|HicEst}}==
<syntaxhighlight lang=
DO i = 1, 10
sum = sum + i^2
Line 956:
=={{header|Icon}} and {{header|Unicon}}==
<syntaxhighlight lang=
every put(x := [], 1 to 10)
writes("x := [ "); every writes(!x," "); write("]")
Line 963:
<syntaxhighlight lang=
local m
if *L = 0 then fail
Line 971:
=={{header|Io}}==
<syntaxhighlight lang=
rms( Range 1 to(10) asList ) println</syntaxhighlight>
Line 977:
=={{header|J}}==
'''Solution:'''
<syntaxhighlight lang="j">rms=: (+/ % #)&.:*:</syntaxhighlight>
'''Example Usage:'''
<syntaxhighlight lang="j"> rms 1 + i. 10
6.20484</syntaxhighlight>
<code>*:</code> means [http://jsoftware.com/help/dictionary/d112.htm square]
Line 989:
=={{header|Java}}==
<syntaxhighlight lang="java">public class RootMeanSquare {
public static double rootMeanSquare(double... nums) {
Line 1,010:
{{works with|JavaScript|1.8}}
{{works with|Firefox|3.0}}
<syntaxhighlight lang="javascript">function root_mean_square(ary) {
var sum_of_squares = ary.reduce(function(s,x) {return (s + x*x)}, 0);
return Math.sqrt(sum_of_squares / ary.length);
Line 1,020:
===ES6===
<syntaxhighlight lang=
'use strict';
Line 1,044:
=={{header|jq}}==
The following filter returns ''null'' if given an empty array:
<syntaxhighlight lang="jq">def rms: length as $length
| if $length == 0 then null
else map(. * .) | add | sqrt / $length
end ;</syntaxhighlight>With this definition, the following program would compute the rms of each array in a file or stream of numeric arrays:<syntaxhighlight lang="jq">rms</syntaxhighlight>
=={{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:
<syntaxhighlight lang="julia">sqrt(sum(A.^2.) / length(A))</syntaxhighlight>
or shorter with using Statistics (and as spoken: root-mean-square)
<syntaxhighlight lang="julia">sqrt(mean(A.^2.))</syntaxhighlight>
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: <syntaxhighlight lang="julia">sqrt(sum(x -> x*x, A) / length(A))</syntaxhighlight>
One can also use an explicit loop for near-C performance
<syntaxhighlight lang="julia">
function rms(A)
s = 0.0
Line 1,065:
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): <syntaxhighlight lang="julia">norm(A) / sqrt(length(A))</syntaxhighlight>
=={{header|K}}==
<syntaxhighlight lang=
rms:{_sqrt (+/x^2)%#x}
rms 1+!10
Line 1,075:
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.0.5-2
fun quadraticMean(vector: Array<Double>) : Double {
Line 1,093:
=={{header|Lasso}}==
<syntaxhighlight lang=
return math_sqrt((with n in #a sum #n*#n) / decimal(#a->size))
}
Line 1,102:
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">' [RC] Averages/Root mean square
SourceList$ ="1 2 3 4 5 6 7 8 9 10"
Line 1,130:
=={{header|Logo}}==
<syntaxhighlight lang="logo">to rms :v
output sqrt quotient (apply "sum map [? * ?] :v) count :v
end
Line 1,137:
=={{header|Lua}}==
<syntaxhighlight lang="lua">function sumsq(a, ...) return a and a^2 + sumsq(...) or 0 end
function rms(t) return (sumsq(unpack(t)) / #t)^.5 end
Line 1,143:
=={{header|Maple}}==
<syntaxhighlight lang=
RMS := proc( x )
return sqrt( Statistics:-Mean( x ^~ 2 ) );
Line 1,154:
=={{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}}==
<syntaxhighlight lang=
rms = sqrt(mean(list.^2));
end</syntaxhighlight>
Solution:
<syntaxhighlight lang=
ans =
Line 1,169:
=={{header|Maxima}}==
<syntaxhighlight lang="maxima">L: makelist(i, i, 10)$
rms(L) := sqrt(lsum(x^2, x, L)/length(L))$
Line 1,176:
=={{header|MAXScript}}==
<syntaxhighlight lang=
fn RMS arr =
(
Line 1,185:
</syntaxhighlight>
Output:
<syntaxhighlight lang=
rms #{1..10}
6.20484
Line 1,192:
=={{header|min}}==
{{works with|min|0.19.6}}
<syntaxhighlight lang="min">(dup *) :sq
('sq map sum) :sum-sq
(('sum-sq 'size) => cleave / sqrt) :rms
Line 1,203:
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">0 П0 П1 С/П x^2 ИП0 x^2 ИП1 *
+ ИП1 1 + П1 / КвКор П0 БП
03</syntaxhighlight>
Line 1,213:
=={{header|Morfa}}==
{{trans|D}}
<syntaxhighlight lang="morfa">
import morfa.base;
import morfa.functional.base;
Line 1,235:
=={{header|Nemerle}}==
<syntaxhighlight lang=
using System.Console;
using System.Math;
Line 1,254:
=={{header|NetRexx}}==
<syntaxhighlight lang=
options replace format comments java crossref symbols nobinary
Line 1,276:
=={{header|Nim}}==
<syntaxhighlight lang="nim">from math import sqrt, sum
from sequtils import mapIt
Line 1,289:
=={{header|Oberon-2}}==
Oxford Oberon-2
<syntaxhighlight lang="oberon2">
MODULE QM;
IMPORT ML := MathL, Out;
Line 1,321:
=={{header|Objeck}}==
<syntaxhighlight lang="objeck">bundle Default {
class Hello {
function : Main(args : String[]) ~ Nil {
Line 1,341:
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let rms a =
sqrt (Array.fold_left (fun s x -> s +. x*.x) 0.0 a /.
float_of_int (Array.length a))
Line 1,351:
=={{header|Oforth}}==
<syntaxhighlight lang=
{{out}}
Line 1,359:
=={{header|ooRexx}}==
<syntaxhighlight lang=
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,392:
=={{header|Oz}}==
<syntaxhighlight lang="oz">declare
fun {Square X} X*X end
Line 1,410:
=={{header|PARI/GP}}==
General RMS calculation:
<syntaxhighlight lang="parigp">RMS(v)={
sqrt(sum(i=1,#v,v[i]^2)/#v)
};
Line 1,417:
Specific functions for the first ''n'' positive integers:
<syntaxhighlight lang="parigp">RMS_first(n)={
sqrt((n+1)*(2*n+1)/6)
};
Line 1,425:
=={{header|Perl}}==
<syntaxhighlight lang="perl">use v5.10.0;
sub rms
{
Line 1,436:
=={{header|Phix}}==
<!--<syntaxhighlight lang=
<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>
Line 1,453:
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=
<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>
Line 1,463:
=={{header|Phixmonti}}==
<syntaxhighlight lang=
0 swap
len for
Line 1,479:
=={{header|PHP}}==
<syntaxhighlight lang=
// Created with PHP 7.0
Line 1,503:
{{trans|Prolog}}
{{works with|Picat}}
<syntaxhighlight lang=
rms(Xs) = Y =>
Sum = sum_of_squares(Xs),
Line 1,525:
=={{header|PicoLisp}}==
<syntaxhighlight lang=
(let Lst (1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0)
Line 1,541:
=={{header|PL/I}}==
<syntaxhighlight lang=
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,552:
=={{header|PostScript}}==
<syntaxhighlight lang="postscript">/findrms{
/x exch def
/sum 0 def
Line 1,573:
</pre>
{{libheader|initlib}}
<syntaxhighlight lang="postscript">[1 10] 1 range dup 0 {dup * +} fold exch length div sqrt</syntaxhighlight>
=={{header|Potion}}==
<syntaxhighlight lang=
total = 0.0
series each (x): total += x * x.
Line 1,587:
=={{header|Powerbuilder}}==
<syntaxhighlight lang="powerbuilder">long ll_x, ll_y, ll_product
decimal ld_rms
Line 1,601:
=={{header|PowerShell}}==
<syntaxhighlight lang=
$sqsum=$nums | foreach-object { $_*$_} | measure-object -sum | select-object -expand Sum
return [math]::sqrt($sqsum/$nums.count)
Line 1,609:
=={{header|Processing}}==
<syntaxhighlight lang="processing">void setup() {
float[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
print(rms(numbers));
Line 1,627:
=={{header|Prolog}}==
{{works with|GNU Prolog}}
<syntaxhighlight lang=
:- initialization(main).
Line 1,652:
=={{header|PureBasic}}==
<syntaxhighlight lang=
If OpenConsole()
Line 1,682:
=={{header|Python}}==
{{works with|Python|3}}
<syntaxhighlight lang=
>>> def qmean(num):
return sqrt(sum(n*n for n in num)/len(num))
Line 1,694:
Alternatively in terms of '''reduce''':
<syntaxhighlight lang="python">from functools import (reduce)
from math import (sqrt)
Line 1,710:
=={{header|Qi}}==
<syntaxhighlight lang="qi">(define rms
R -> (sqrt (/ (APPLY + (MAPCAR * R R)) (length R))))</syntaxhighlight>
Line 1,718:
Using the Quackery big number rational arithmetic library <code>bigrat.qky</code>.
<syntaxhighlight lang=
[ [] swap
Line 1,756:
The following function works for any vector x:
<syntaxhighlight lang="rsplus">RMS <- function(x, na.rm = F) sqrt(mean(x^2, na.rm = na.rm))
RMS(1:10)
Line 1,768:
=={{header|Racket}}==
<syntaxhighlight lang=
#lang racket
(define (rms nums)
Line 1,777:
(formerly Perl 6)
<syntaxhighlight lang=
say rms 1..10;</syntaxhighlight>
Here's a slightly more concise version, albeit arguably less readable:
<syntaxhighlight lang=
=={{header|REXX}}==
Line 1,792:
<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.
<syntaxhighlight lang="rexx">/*REXX program computes and displays the root mean square (RMS) of a number sequence. */
parse arg nums digs show . /*obtain the optional arguments from CL*/
if nums=='' | nums=="," then nums=10 /*Not specified? Then use the default.*/
Line 1,817:
=={{header|Ring}}==
<syntaxhighlight lang="ring">
nums = [1,2,3,4,5,6,7,8,9,10]
sum = 0
Line 1,832:
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">class Array
def quadratic_mean
Math.sqrt( self.inject(0.0) {|s, y| s + y*y} / self.length )
Line 1,847:
and a non object-oriented solution:
<syntaxhighlight lang="ruby">def rms(seq)
Math.sqrt(seq.sum{|x| x*x}.fdiv(seq.size) )
end
Line 1,853:
=={{header|Run BASIC}}==
<syntaxhighlight lang="runbasic">valueList$ = "1 2 3 4 5 6 7 8 9 10"
while word$(valueList$,i +1) <> "" ' grab values from list
thisValue = val(word$(valueList$,i +1)) ' turn values into numbers
Line 1,867:
=={{header|Rust}}==
<syntaxhighlight lang="rust">fn root_mean_square(vec: Vec<i32>) -> f32 {
let sum_squares = vec.iter().fold(0, |acc, &x| acc + x.pow(2));
return ((sum_squares as f32)/(vec.len() as f32)).sqrt();
Line 1,888:
built-in syntax.
<syntaxhighlight lang=
{
return sqrt(sum(sqr(arr)) / length(arr));
Line 1,896:
=={{header|Sather}}==
<syntaxhighlight lang="sather">class MAIN is
-- irrms stands for Integer Ranged RMS
irrms(i, f:INT):FLT
Line 1,914:
=={{header|S-BASIC}}==
<syntaxhighlight lang="basic">
var n, sqsum, sqmean, rms = real
sqsum = 0
Line 1,932:
=={{header|Scala}}==
<syntaxhighlight lang="scala">def rms(nums: Seq[Int]) = math.sqrt(nums.map(math.pow(_, 2)).sum / nums.size)
println(rms(1 to 10))</syntaxhighlight>
{{out}}
Line 1,938:
=={{header|Scheme}}==
<syntaxhighlight lang="scheme">(define (rms nums)
(sqrt (/ (apply + (map * nums nums))
(length nums))))
Line 1,947:
=={{header|Seed7}}==
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "float.s7i";
include "math.s7i";
Line 1,973:
=={{header|Shen}}==
{{works with|shen-scheme|0.17}}
<syntaxhighlight lang=
(tc +)
Line 2,001:
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">func rms(a) {
sqrt(a.map{.**2}.sum / a.len)
}
Line 2,008:
Using hyper operators, we can write it as:
<syntaxhighlight lang="ruby">func rms(a) { a »**» 2 «+» / a.len -> sqrt }</syntaxhighlight>
{{out}}
Line 2,014:
=={{header|Smalltalk}}==
<syntaxhighlight lang="smalltalk">(((1 to: 10) inject: 0 into: [ :s :n | n*n + s ]) / 10) sqrt.</syntaxhighlight>
=={{header|SNOBOL4}}==
Line 2,020:
{{works with|CSnobol}}
There is no built-in sqrt( ) function in Snobol4+.
<syntaxhighlight lang=
rms i = i + 1; ssq = ssq + (a<i> * a<i>) :s(rms)
rms = sqrt(1.0 * ssq / prototype(a)) :(return)
Line 2,034:
=={{header|Standard ML}}==
<syntaxhighlight lang="sml">fun rms(v: real vector) =
let
val v' = Vector.map (fn x => x*x) v
Line 2,049:
Compute the RMS of a variable and return the result in r(rms).
<syntaxhighlight lang="stata">program rms, rclass
syntax varname(numeric) [if] [in]
tempvar x
Line 2,059:
'''Example'''
<syntaxhighlight lang="stata">clear
set obs 20
gen x=rnormal()
Line 2,073:
=={{header|Swift}}==
<syntaxhighlight lang="swift">extension Collection where Element: FloatingPoint {
@inlinable
public func rms() -> Element {
Line 2,088:
=={{header|Tcl}}==
{{works with|Tcl|8.5}}
<syntaxhighlight lang="tcl">proc qmean list {
set sum 0.0
foreach value $list { set sum [expr {$sum + $value**2}] }
Line 2,102:
=={{header|Ursala}}==
using the <code>mean</code> function among others from the <code>flo</code> library
<syntaxhighlight lang=
#import flo
Line 2,115:
=={{header|Vala}}==
Valac probably needs to have the flag "-X -lm" added to include the C Math library.
<syntaxhighlight lang="vala">double rms(double[] list){
double sum_squares = 0;
double mean;
Line 2,141:
=={{header|VBA}}==
Using Excel VBA
<syntaxhighlight lang="vb">Private Function root_mean_square(s() As Variant) As Double
For i = 1 To UBound(s)
s(i) = s(i) ^ 2
Line 2,153:
End Sub</syntaxhighlight>
Without using Excel worksheetfunction:
<syntaxhighlight lang="vb">Function rms(iLow As Integer, iHigh As Integer)
Dim i As Integer
If iLow > iHigh Then
Line 2,177:
=={{header|Vlang}}==
<syntaxhighlight lang="vlang">import math
fn main() {
Line 2,194:
=={{header|Wortel}}==
<syntaxhighlight lang="wortel">@let {
; using a composition and a fork (like you would do in J)
rms1 ^(@sqrt @(@sum / #) *^@sq)
Line 2,210:
=={{header|Wren}}==
<syntaxhighlight lang="ecmascript">var rms = ((1..10).reduce(0) { |acc, i| acc + i*i }/10).sqrt
System.print(rms)</syntaxhighlight>
Line 2,219:
=={{header|XLISP}}==
<syntaxhighlight lang="lisp">(defun quadratic-mean (xs)
(sqrt
(/
Line 2,239:
=={{header|XPL0}}==
<syntaxhighlight lang=
code real RlOut=48;
int N;
Line 2,254:
=={{header|Yacas}}==
<syntaxhighlight lang=
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}}==
<syntaxhighlight lang="zkl">fcn rms(z){ ( z.reduce(fcn(p,n){ p + n*n },0.0) /z.len() ).sqrt() }</syntaxhighlight>
The order in the reduce function is important as it coerces n*n to float.
<pre>
| |||