Sum of squares: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
Not a robot (talk | contribs) (Add BCPL) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
(40 intermediate revisions by 23 users not shown) | |||
Line 12:
=={{header|0815}}==
<
{x{*%<:d:~$<:1:~>><:2:~>><:3:~>><:4:~>><:5:~>><:6:~>><:7:
~>><:8:~>><:9:~>><:a:~>><:b:~>><:c:~>><:ffffffffffffffff:
~>{x{*>}:8f:{x{*&{=+>{~>&=x<:ffffffffffffffff:/#:8f:{{~%
</syntaxhighlight>
{{out}}
<pre>
Line 24:
=={{header|11l}}==
<
{{out}}
Line 32:
=={{header|360 Assembly}}==
<
SUMOFSQR CSECT
USING SUMOFSQR,R12
Line 55:
N DC AL2((PG-A)/4)
YREGS
END SUMOFSQR</
{{out}}
<pre>
Line 63:
=={{header|8086 Assembly}}==
<
cpu 8086
bits 16
Line 117:
outstr_end: db '$'
array: dw 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20
arrlen: equ ($-array)/2 ; length is in words</
=={{header|ACL2}}==
<
(if (endp xs)
0
(+ (* (first xs) (first xs))
(sum-of-squares (rest xs)))))</
=={{header|Action!}}==
<syntaxhighlight lang="action!">CARD FUNC SumOfSqr(BYTE ARRAY a BYTE count)
BYTE i
CARD res
IF count=0 THEN
RETURN (0)
FI
res=0
FOR i=0 TO count-1
DO
res==+a(i)*a(i)
OD
RETURN (res)
PROC Test(BYTE ARRAY a BYTE count)
BYTE i
CARD res
res=SumOfSqr(a,count)
Print("[")
IF count>0 THEN
FOR i=0 to count-1
DO
PrintB(a(i))
IF i<count-1 THEN
Put(' )
FI
OD
FI
PrintF("]->%U%E%E",res)
RETURN
PROC Main()
BYTE ARRAY a=[1 2 3 4 5]
BYTE ARRAY b=[10 20 30 40 50 60 70 80 90]
BYTE ARRAY c=[11]
Test(a,5)
Test(b,9)
Test(c,1)
Test(c,0)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sum_of_squares.png Screenshot from Atari 8-bit computer]
<pre>
[1 2 3 4 5]->55
[10 20 30 40 50 60 70 80 90]->28500
[11]->121
[]->0
</pre>
=={{header|ActionScript}}==
<
{
var sum:Number = 0;
Line 133 ⟶ 189:
sum += vector[i]*vector[i];
return sum;
}</
=={{header|Ada}}==
<
procedure Test_Sum_Of_Squares is
Line 153 ⟶ 209:
Put_Line (Float'Image (Sum_Of_Squares ((1..0 => 1.0)))); -- Empty array
Put_Line (Float'Image (Sum_Of_Squares ((3.0, 1.0, 4.0, 1.0, 5.0, 9.0))));
end Test_Sum_Of_Squares;</
{{out}}
<pre>
Line 161 ⟶ 217:
=={{header|Aime}}==
<
squaredsum(list l)
{
Line 188 ⟶ 244:
0;
}</
{{out}}
<pre>14
0
4.5</pre>
=={{header|ALGOL 60}}==
{{works with|GNU Marst|Any - tested with release 2.7}}
Using [[Jensen's Device]].
<syntaxhighlight lang="algol60">
begin
integer i;
integer array A[ 1 : 5 ];
real procedure sum (i, lo, hi, term);
value lo, hi;
integer i, lo, hi;
real term;
comment term is passed by-name, and so is i;
begin
real temp;
temp := 0;
for i := lo step 1 until hi do
temp := temp + term;
sum := temp
end;
comment initialie A;
for i := 1 step 1 until 5 do A[i] := i;
comment note the correspondence between the mathematical notation and the call to sum;
outreal(1, sum (i, 1, 5, A[i] * A[i]))
end
</syntaxhighlight>
=={{header|ALGOL 68}}==
Line 202 ⟶ 284:
The computation can be written as a loop.
<
REAL sum := 0;
FOR i FROM LWB argv TO UPB argv DO
Line 211 ⟶ 293:
test:(
printf(($g(0)l$,sum of squares([]REAL(3, 1, 4, 1, 5, 9))));
)</
{{out}}
<pre>
Line 219 ⟶ 301:
{{trans|python}}
<
PROC map = ( PROC(REAL)REAL func, []REAL argv)REAL:
Line 234 ⟶ 316:
sum := 0;
printf(($g(0)l$, ((REAL argv)REAL: sum +:= argv ** 2) MAP data ))
)</
{{out}}
<pre>
Line 246 ⟶ 328:
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}
The computation can be written as a generator.
<
# -*- coding: utf-8 -*- #
Line 289 ⟶ 371:
printf(($"SUMSQ GEN: "g(0)l$, SUMSQ GEN data));
printf(($"sq SUMMAP GEN: "g(0)l$, ((REAL x)REAL: x*x)SUMMAP GEN data))
)</
{{out}}
<pre>
Line 301 ⟶ 383:
=={{header|ALGOL W}}==
===Using a dedicated
<syntaxhighlight lang="algolw">begin
% procedure to sum the squares of the elements of a vector. %
% the bounds of the vector must be passed in lb and ub %
real procedure sumSquares ( real array vector ( * )
; integer value lb
Line 320 ⟶ 405:
r_format := "A"; r_w := 10; r_d := 1; % set fixed point output %
write( sumSquares( numbers, 1, 5 ) );
end.</
===Using Jensen's device===
{{Trans|ALGOL60}}
Using the classic [[Jensen's Device]] (first introduced in Algol 60) we can use a generic summation procedure, as in this sample:
<syntaxhighlight lang="algolw">
begin % sum the squares of the elements of a vector, using Jensen's Device %
integer i;
real procedure sum ( integer %name% i; integer value lo, hi; real procedure term );
% i is passed by-name, term is passed as a procedure which makes it effectively passed by-name %
begin
real temp;
temp := 0;
i := lo;
while i <= hi do begin % The Algol W "for" loop (as in Algol 68) creates a distinct %
temp := temp + term; % variable which would not be shared with the passed "i" %
i := i + 1 % Here the actual passed "i" is incremented. %
end while_i_le_temp;
temp
end;
real array A ( 1 :: 5 );
for i := 1 until 5 do A( i ) := i;
r_format := "A"; r_w := 10; r_d := 1; % set fixed point output %
write( sum( i, 1, 5, A( i ) * A( i ) ) );
end.
</syntaxhighlight>
=={{header|Alore}}==
<
var sum = 0
for i in a
Line 333 ⟶ 444:
WriteLn(sum_squares([3,1,4,1,5,9]))
end</
=={{header|APL}}==
<
square_sum 1 2 3 4 5
55
square_sum ⍬ ⍝The empty vector
0</
=={{header|AppleScript}}==
Two ways of composing a sumOfSquares function:
<
-- sumOfSquares :: Num a => [a] -> a
Line 431 ⟶ 542:
foldl(add, 0, xs)
end sum</
{{Out}}
<syntaxhighlight lang
=={{header|Arturo}}==
<
print sum map arr [x][x^2]</
{{out}}
Line 445 ⟶ 556:
=={{header|Astro}}==
<
=={{header|Asymptote}}==
<syntaxhighlight lang="asymptote">int suma;
int[] a={1, 2, 3, 4, 5, 6};
for(var i : a)
suma = suma + a[i] ^ 2;
write("The sum of squares is: ", suma);</syntaxhighlight>
=={{header|AutoHotkey}}==
<
Loop, Parse, list, %A_Space%
sum += A_LoopField**2
MsgBox,% sum</
=={{header|AWK}}==
Vectors are read, space-separated, from stdin; sum of squares goes to stdout. The empty line produces 0.
<
3 1 4 1 5 9
133
0</
=={{header|BASIC}}==
{{works with|QBasic}}
Assume the numbers are in an array called <code>a</code>.
<
FOR I = LBOUND(a) TO UBOUND(a)
sum = sum + a(I) ^ 2
NEXT I
PRINT "The sum of squares is: " + sum</
==={{header|BaCon}}===
<
FUNCTION ss(int arr[], NUMBER elem)
sum = 0
Line 492 ⟶ 612:
vector[i] = i + 1
NEXT
PRINT ss(vector, elem)</
{{out}}
Line 499 ⟶ 619:
prompt$ ./sumsquares -s 1000
333833500</pre>
==={{header|BASIC256}}===
<syntaxhighlight lang="basic256">arraybase 1
dim a(6)
a[1] = 1.0
a[2] = 2.0
a[3] = 3.0
a[4] = -1.0
a[5] = -2.0
a[6] = -3.0
sum = 0
for i = 1 to a[?]
sum += a[i] ^ 2
next i
print "The sum of squares is: "; sum
end</syntaxhighlight>
==={{header|BBC BASIC}}===
BBC BASIC cannot have a zero-length array.
<
vector() = 1, 2, 3, 4, 5, 6
PRINT "Sum of squares = " ; MOD(vector()) ^ 2</
{{out}}
<pre>Sum of squares = 91</pre>
==={{header|IS-BASIC}}===
<
110 NUMERIC A(1 TO N)
120 FOR I=1 TO N
Line 522 ⟶ 660:
200 NEXT
210 LET SQ=S
220 END DEF</
==={{header|Yabasic}}===
<syntaxhighlight lang="yabasic">data 1.0, 2.0, 3.0, -1.0, -2.0, -3.0
dim a(5)
sum = 0
for i = 0 to arraysize(a(), 1)
read a(i)
sum = sum + a(i) ^ 2
next i
print "The sum of squares is: ", sum
end</syntaxhighlight>
=={{header|bc}}==
<
auto i, s
Line 533 ⟶ 683:
return(s)
}</
=={{header|BCPL}}==
<
let sumsquares(v, len) =
Line 545 ⟶ 695:
$( let vector = table 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
writef("%N*N", sumsquares(vector, 10))
$)</
{{out}}
<pre>385</pre>
=={{header|BQN}}==
Similar to the BQN entry in [[Sum of a series]].
<syntaxhighlight lang="bqn">SSq ← +´√⁼
•Show SSq 1‿2‿3‿4‿5
•Show SSq ⟨⟩</syntaxhighlight>
<syntaxhighlight lang="text">55
0</syntaxhighlight>
=={{header|Bracmat}}==
<
= sum component
. 0:?sum
Line 562 ⟶ 720:
& out$(sumOfSquares$(3 4 i*5))
& out$(sumOfSquares$(a b c))
);</
{{out}}
<pre>25
Line 569 ⟶ 727:
=={{header|Brat}}==
<
=={{header|C}}==
<
double squaredsum(double *l, int e)
Line 591 ⟶ 749:
printf("%lf\n", squaredsum(NULL, 0));
return 0;
}</
=={{header|C sharp|C#}}==
<
using System.Collections.Generic;
using System.Linq;
Line 611 ⟶ 769:
Console.WriteLine(SumOfSquares(new int[] { })); // 0
}
}</
=={{header|C++}}==
===Using accumulate===
<
#include <numeric>
#include <vector>
Line 640 ⟶ 798:
std::cout << vec_add_squares(v) << std::endl;
return 0;
}</
===Using inner_product===
<
#include <numeric>
#include <vector>
Line 657 ⟶ 815:
std::cout << std::inner_product(begin(v), end(v), begin(v), 0.0) << std::endl;
return 0;
}</
===Using Boost.Lambda===
{{libheader|Boost.Lambda}}
<
#include <vector>
#include "boost/lambda/lambda.hpp"
Line 670 ⟶ 828:
return std::accumulate(v.begin(), v.end(), 0.0, _1 + _2 * _2);
}</
=={{header|Chef}}==
<
First input is length of vector, then rest of input is vector.
Line 695 ⟶ 853:
Serves 1.
</syntaxhighlight>
=={{header|Clojure}}==
<
(reduce #(+ %1 (* %2 %2)) 0 v))</
=={{header|CLU}}==
<syntaxhighlight lang="clu">sum_squares = proc (ns: sequence[int]) returns (int)
sum: int := 0
for n: int in sequence[int]$elements(ns) do
sum := sum + n ** 2
end
return(sum)
end sum_squares
start_up = proc ()
po: stream := stream$primary_output()
stream$putl(po, int$unparse(sum_squares(sequence[int]$[])))
stream$putl(po, int$unparse(sum_squares(sequence[int]$[1,2,3,4,5])))
stream$putl(po, int$unparse(sum_squares(sequence[int]$[42])))
end start_up</syntaxhighlight>
{{out}}
<pre>0
55
1764</pre>
=={{header|CoffeeScript}}==
<
sumOfSquares = ( list ) ->
list.reduce (( sum, x ) -> sum + ( x * x )), 0
</syntaxhighlight>
=={{header|Common Lisp}}==
<
(loop for x across vector sum (expt x 2)))</
Or in a functional way:
<syntaxhighlight lang="lisp">(defun sum-of-squares (vec)
(reduce #'+ (map 'vector (lambda (x) (* x x)) vec)))</syntaxhighlight>
=={{header|Cowgol}}==
<
include "argv.coh";
Line 749 ⟶ 932:
# Print sum of squares of numbers
print_i32(sumsquare(&nums[0], len as intptr));
print_nl();</
{{out}}
Line 762 ⟶ 945:
=={{header|Crystal}}==
<syntaxhighlight lang="ruby">
def sum_squares(a)
a.map{|e| e*e}.sum()
Line 769 ⟶ 952:
puts sum_squares([1, 2, 3])
# => 14
</syntaxhighlight>
=={{header|D}}==
===Iterative Version===
<
T sum = 0;
foreach (e; a)
Line 784 ⟶ 967:
[3.1, 1.0, 4.0, 1.0, 5.0, 9.0].sumSquares.writeln;
}</
{{out}}
<pre>133.61</pre>
===Polymorphic Functional Style===
<
auto sumSquares(Range)(Range data) pure nothrow @safe @nogc {
Line 799 ⟶ 982:
items.sumSquares.writeln;
10.iota.sumSquares.writeln;
}</
{{out}}
<pre>133.61
Line 806 ⟶ 989:
=={{header|Dart}}==
===Iterative Version===
<
var sum=0;
list.forEach((var n) { sum+=(n*n); });
Line 816 ⟶ 999:
print(sumOfSquares([1,2,3]));
print(sumOfSquares([10]));
}</
{{out}}
<pre>0
Line 823 ⟶ 1,006:
===Functional Style Version===
<
.fold(0, (num p,num n)=> p + n);
Line 830 ⟶ 1,013:
print(sumOfSquares([1,2,3]));
print(sumOfSquares([10]));
}</
{{out}}
<pre>0
Line 838 ⟶ 1,021:
=={{header|Delphi}}==
Delphi has standard SumOfSquares function in Math unit:
<
{$APPTYPE CONSOLE}
Line 858 ⟶ 1,041:
Writeln(SumOfSquares(A):6:2); // 30.00
Readln;
end.</
=={{header|Draco}}==
<syntaxhighlight lang="draco">proc nonrec sum_squares([*] int arr) ulong:
ulong sum, item;
word i, len;
sum := 0;
len := dim(arr,1);
if len>0 then
for i from 0 upto len-1 do
item := |arr[i];
sum := sum + item * item
od
fi;
sum
corp
proc nonrec main() void:
type A0 = [0] int,
A1 = [1] int,
A5 = [5] int;
writeln(sum_squares(A0()));
writeln(sum_squares(A1(42)));
writeln(sum_squares(A5(1,2,3,4,5)))
corp</syntaxhighlight>
{{out}}
<pre>0
1764
55</pre>
=={{header|E}}==
<
var sum := 0
for x in numbers {
Line 868 ⟶ 1,080:
}
return sum
}</
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
nums[] = [ 1 2 3 4 5 ]
for v in nums[]
sum += v * v
.
print sum
</syntaxhighlight>
=={{header|Eiffel}}==
<syntaxhighlight lang="eiffel">
class
APPLICATION
Line 904 ⟶ 1,126:
end
</syntaxhighlight>
=={{header|Elena}}==
ELENA
<
import extensions;
SumOfSquares(list)
= list.selectBy::(x => x * x).summarize(new Integer());
public program()
Line 920 ⟶ 1,142:
.printLine(SumOfSquares(new int[]{1, 2, 3, 4, 5}))
.printLine(SumOfSquares(Array.MinValue))
}</
{{out}}
<pre>
Line 929 ⟶ 1,151:
=={{header|Elixir}}==
<
133</
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(defun sum-of-squares (numbers)
(apply #'+ (mapcar (lambda (k) (* k k)) numbers)))
=={{header|Erlang}}==
<
=={{header|Euler}}==
Using [[Jensen's Device]]
'''begin'''
'''new''' i; '''new''' A; '''new''' sum;
sum <- ` '''formal''' i; '''formal''' lo; '''formal''' hi; '''formal''' term;
'''begin'''
'''new''' temp; '''label''' loop;
temp <- 0;
i <- lo;
loop: '''begin'''
temp <- temp + term;
'''if''' [ i <- i + 1 ] <= hi '''then''' '''goto''' loop '''else''' 0
'''end''';
temp
'''end'''
';
A <- ( 1, 2, 3, 4, 5 );
'''out''' sum( @i, 1, '''length''' A, `A[i]*A[i]' )
'''end''' $
=={{header|Euphoria}}==
<
atom sum
sum = 0
Line 955 ⟶ 1,192:
end for
return sum
end function</
=={{header|Excel}}==
To find the sum of squares of values from A1 to A10, type in any other cell :
<syntaxhighlight lang="excel">
=SUMSQ(A1:A10)
</syntaxhighlight>
The above expression will return zero if there are no values in any cell.
<syntaxhighlight lang="text">
12 3 5 23 13 67 15 9 4 2
5691
</syntaxhighlight>
=={{header|F_Sharp|F#}}==
<
[|1 .. 10|] |> Array.fold (fun a x -> a + x * x) 0</
=={{header|Factor}}==
<
: sum-of-squares ( seq -- n ) [ sq ] map-sum ;
{ 1.0 2.0 4.0 8.0 16.0 } sum-of-squares</
=={{header|FALSE}}==
<syntaxhighlight lang="false">
0 3 1 4 1 5 9$*\ [$0=~][$*+\]#%.
</syntaxhighlight>
=={{header|Fantom}}==
<
class SumSquares
{
Line 1,007 ⟶ 1,244:
}
}
</syntaxhighlight>
=={{header|Fish}}==
<syntaxhighlight lang="fish">v
\0&
>l?!v:*&+&
>&n;</
=={{header|Forth}}==
<
0e
dup 0= if 2drop exit then
Line 1,024 ⟶ 1,261:
create test 3e f, 1e f, 4e f, 1e f, 5e f, 9e f,
test 6 fsum**2 f. \ 133.</
=={{header|Fortran}}==
In ISO Fortran 90 orlater, use SUM intrinsic and implicit element-wise array arithmetic:
<
real, pointer, dimension(:) :: p => a(2:1) ! pointer to zero-length array
real :: result, zresult
Line 1,036 ⟶ 1,273:
result = sum(a**2) ! Use exponentiation operator to get squares
zresult = sum(p*p) ! P is zero-length; P*P is valid zero-length array expression; SUM(P*P) == 0.0 as expected</
=={{header|FreeBASIC}}==
<
Function SumSquares(a() As Double) As Double
Line 1,056 ⟶ 1,293:
Print
Print "Press any key to quit"
Sleep</
{{out}}
Line 1,064 ⟶ 1,301:
=={{header|Frink}}==
<
f = {|x| x^2} // Anonymous function which squares its argument
a = [1,2,3,5,7]
println[sum[map[f,a], 0]]
</syntaxhighlight>
=={{header|Fōrmulæ}}==
'''Solution'''
[[File:Fōrmulæ - Sum of squares 01.png]]
'''Test cases'''
[[File:Fōrmulæ - Sum of squares 02.png]]
[[File:Fōrmulæ - Sum of squares 03.png]]
[[File:Fōrmulæ - Sum of squares 04.png]]
[[File:Fōrmulæ - Sum of squares 05.png]]
[[File:Fōrmulæ - Sum of squares 06.png]]
[[File:Fōrmulæ - Sum of squares 07.png]]
=={{header|GAP}}==
<
# It's necessary to check for the empty vector though
SumSq := function(v)
Line 1,087 ⟶ 1,338:
return v*v;
fi;
end;</
=={{header|GEORGE}}==
<
0
1, n rep (i)
read print dup mult +
]
print</
data
<pre>
Line 1,130 ⟶ 1,381:
=={{header|Go}}==
;Implementation
<
import "fmt"
Line 1,142 ⟶ 1,393:
}
fmt.Println(sum)
}</
{{out}}
<pre>
Line 1,148 ⟶ 1,399:
</pre>
;Library
<
import (
Line 1,160 ⟶ 1,411:
func main() {
fmt.Println(floats.Dot(v, v))
}</
{{out}}
<pre>
Line 1,167 ⟶ 1,418:
=={{header|Golfscript}}==
<
# usage example
[1 2 3]sqsum puts</
=={{header|Groovy}}==
<
// square via multiplication
Line 1,181 ⟶ 1,432:
sumSq = array.collect { it ** 2 }.sum()
println sumSq</
{{out}}
Line 1,189 ⟶ 1,440:
=={{header|Haskell}}==
Three approaches:
<
versions =
[ sum . fmap (^ 2) -- ver 1
Line 1,198 ⟶ 1,449:
main :: IO ()
main =
mapM_ print ((`fmap` [[3, 1, 4, 1, 5, 9], [1 .. 6], [], [1]]) <$> versions)</
{{Out}}
<pre>[133,91,0,1]
Line 1,205 ⟶ 1,456:
=={{header|Icon}} and {{header|Unicon}}==
<
local lst
lst := []
Line 1,218 ⟶ 1,469:
every total +:= !lst ^ 2
return total
end</
=={{header|IDL}}==
<syntaxhighlight lang
=={{header|Inform 7}}==
<
To decide which number is the sum of (N - number) and (M - number) (this is summing):
Line 1,240 ⟶ 1,491:
say line break;
say the sum of squares of {1, 2, 3};
end the story.</
=={{header|Io}}==
<
=={{header|J}}==
<
That is, sum composed with square. The verb also works on higher-ranked arrays. For example:
<
133
ss $0 NB. $0 is a zero-length vector
Line 1,257 ⟶ 1,508:
x=: 20 4 ?@$ 0 NB. a 20-by-4 table of random (0,1) numbers
ss x
9.09516 5.19512 5.84173 6.6916</
The computation can also be written as a loop. It is shown here for comparison only and
is highly non-preferred compared to the version above.
<
z=. 0
for_i. i.#y do. z=. z+*:i{y end.
Line 1,272 ⟶ 1,523:
0
ss1 x
9.09516 5.19512 5.84173 6.6916</
=={{header|Java}}==
{{works with|Java|1.5+}}
<
{
public static void main(final String[] args)
Line 1,286 ⟶ 1,537:
System.out.println("The sum of the squares is: " + sum);
}
}</
=={{header|JavaScript}}==
===ES5===
<
var sum = 0;
var i, iLen;
Line 1,300 ⟶ 1,551:
}
alert(sumsq([1,2,3,4,5])); // 55</
An alternative using a while loop and Math.pow
<
var sum = 0,
i = array.length;
Line 1,313 ⟶ 1,564:
}
alert(sumsq([1,2,3,4,5])); // 55</
{{libheader|Functional}}<
map (JS 1.6) and reduce (JS 1.8)
<
===ES6===
Two ways of composing a sumOfSquares function
<
'use strict';
Line 1,359 ⟶ 1,610:
// MAIN ---
return main();
})();</
{{Out}}
<pre>133
133</pre>
=={{header|Joy}}==
<syntaxhighlight lang="joy">[1 2 3 4 5] 0 [dup * +] fold.</syntaxhighlight>
=={{header|jq}}==
jq supports both arrays and streams, and so we illustrate how to handle both.
<
def ss: map(.*.) | add;
# ss for a stream, S, without creating an intermediate array:
def ss(S): reduce S as $x (0; . + ($x * $x) );</
# SIGMA(exp) computes the sum of exp over the input array:
def SIGMA(exp): map(exp) | add;
Line 1,376 ⟶ 1,630:
# SIGMA(exp; S) computes the sum of exp over elements of the stream, S,
# without creating an intermediate array:
def SIGMA(exp; S): reduce (S|exp) as $x (0; . + $x);</
Finally, a "mapreduce" filter:<
def mapreduce(mapper; reducer; zero):
if length == 0 then zero
else map(mapper) | reducer
end;
</syntaxhighlight>
Demonstration:<
"ss: \( [range(0;n)] | ss )",
"ss(S): \( ss( range(0;n) ) )",
Line 1,391 ⟶ 1,645:
;
demo(3) # 0^2 + 1^2 + 2^2</
{{out}}
<
"ss(S): 5"
"SIGMA(.*.): 5"
"SIGMA(.*.;S): 5"
"mapreduce(.*.; add; 0): 5"</
=={{header|Julia}}==
There are several easy ways to do this in Julia:
<
55
Line 1,411 ⟶ 1,665:
julia> sum([x^2 for x in []])
0</
=={{header|K}}==
<syntaxhighlight lang="k">
ss: {+/x*x}
ss 1 2 3 4 5
Line 1,420 ⟶ 1,674:
ss@!0
0
</syntaxhighlight>
=={{header|Kotlin}}==
Line 1,431 ⟶ 1,685:
Finally, a classic for-loop can also be used. Note that because <code>forEach</code> and <code>fold</code> are inline functions, these are actually exactly as efficient as the had-written for-loop.
<
import kotlin.system.measureTimeMillis
import kotlin.time.milliseconds
Line 1,482 ⟶ 1,736:
for (v in longArray) acc += v
}
}</
{{out}}
Line 1,509 ⟶ 1,763:
=={{header|Lambdatalk}}==
<
{def sumsq
{lambda {:s}
Line 1,519 ⟶ 1,773:
{sumsq 0}
-> 0
</syntaxhighlight>
=={{header|Lang5}}==
<
=={{header|Lasso}}==
<
local(sum = 0)
Line 1,536 ⟶ 1,790:
}
sumofsquares(array(1,2,3,4,5))</
{{out}}
<pre>55</pre>
=={{header|LFE}}==
<
(defun sum-sq (nums)
(lists:foldl
Line 1,547 ⟶ 1,801:
(+ acc (* x x)))
0 nums))
</syntaxhighlight>
Usage:
<
> (sum-sq '(3 1 4 1 5 9))
133
</syntaxhighlight>
=={{header|Liberty BASIC}}==
<
SourceList$ ="3 1 4 1 5 9"
Line 1,582 ⟶ 1,836:
print "Sum of squares is "; SumOfSquares
end</
=={{header|LiveCode}}==
<
repeat for each item n in nums
add (n * n) to m
end repeat
put m // 55</
=={{header|Logo}}==
<
=={{header|Logtalk}}==
<
sum(List, 0, Sum).
Line 1,601 ⟶ 1,855:
sum([X| Xs], Acc, Sum) :-
Acc2 is Acc + X,
sum(Xs, Acc2, Sum).</
=={{header|Lua}}==
<
function squaresumt(t) return squaresum(unpack(t)) end
print(squaresumt{3, 5, 4, 1, 7})</
=={{header|M2000 Interpreter}}==
M2000 use two concepts for arrays: standard array like A() and pointer to array as A. Pointer arithmetic not allowed here. Standard arrays are values types, and pointers are reference types. So we can handle an array both with pointer and without.
<syntaxhighlight lang="m2000 interpreter">
Dim A() 'make an array with zero items
Line 1,639 ⟶ 1,893:
Now A and A() prints a 20 item array (Cons() add a list of arrays)
Print A ' or Print A() print the same
</syntaxhighlight>
And this is the task, using a lambda function (we can use a standard function, just use Function Square { code here })
Line 1,647 ⟶ 1,901:
When we pass an array in stack, a pointer to array (to one of two interfaces) and depends the name type of a read to make this a copy or a pointer to array. So here we use: read a as a pointer to array (so it is a by reference pass). We can use Read a() and then a=a() (and remove Link a to a()), so we use by value pass, and that is a decision from callee, not the caller (this happen for objects)
<syntaxhighlight lang="m2000 interpreter">
Module Checkit {
A=(1,2,3,4,5)
Line 1,669 ⟶ 1,923:
}
Checkit
</syntaxhighlight>
=={{header|Maple}}==
<syntaxhighlight lang="maple">
F := V -> add(v^2, v in V):
F(<1,2,3,4,5>);
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
As a function 1:
<
SumOfSquares[{1,2,3,4,5}]</
As a function 2:
<
SumOfSquares[{1,2,3,4,5}]</
Pure function 1: (postfix operator in the following examples)
<
Pure function 2:
<
Pure function 3:
<
=={{header|MATLAB}}==
<
squaredSum = sum( inputVector.^2 );</
=={{header|Maxima}}==
<
sum(nums[i]^2,i,1,length(nums));</
or
<
lsum(el^2, el, nums);</
=={{header|Mercury}}==
<syntaxhighlight lang="text">
:- module sum_of_squares.
:- interface.
Line 1,720 ⟶ 1,974:
sum_of_squares(Ns) = list.foldl((func(N, Acc) = Acc + N * N), Ns, 0).
</syntaxhighlight>
=={{header|min}}==
{{works with|min|0.19.3}}
<
(1 2 3 4 5) sq-sum puts
() sq-sum puts</
{{out}}
<pre>
Line 1,735 ⟶ 1,989:
=={{header|MiniScript}}==
<
sum = 0
for item in seq
Line 1,745 ⟶ 1,999:
print sumOfSquares([4, 8, 15, 16, 23, 42])
print sumOfSquares([1, 2, 3, 4, 5])
print sumOfSquares([])</
{{out}}
<pre>2854
Line 1,752 ⟶ 2,006:
=={{header|МК-61/52}}==
<syntaxhighlight lang="text">x^2 + С/П БП 00</
=={{header|Modula-3}}==
<
IMPORT IO, Fmt;
Line 1,773 ⟶ 2,027:
IO.Put(Fmt.Real(SumOfSquares(RealArray{3.0, 1.0, 4.0, 1.0, 5.0, 9.0})));
IO.Put("\n");
END SumSquares.</
=={{header|MOO}}==
<
@program #100:sum_squares
sum = 0;
Line 1,791 ⟶ 2,045:
;#100:sum_squares({})
{} => 0
</syntaxhighlight>
=={{header|MUMPS}}==
<
;X is assumed to be a list of numbers separated by "^"
NEW RESULT,I
SET RESULT=0,I=1
FOR QUIT:(I>$LENGTH(X,"^")) SET RESULT=($PIECE(X,"^",I)*$PIECE(X,"^",I))+RESULT,I=I+1
QUIT RESULT</
=={{header|Nanoquery}}==
<
if len(vector) = 0
return 0
Line 1,816 ⟶ 2,070:
println sum_squares({})
println sum_squares({1, 2, 3, 4, 5})
println sum_squares({10, 3456, 2, 6})</
{{out}}
<pre>0
Line 1,823 ⟶ 2,077:
=={{header|Nemerle}}==
<
{
|[] => 0.0
|_ => x.Map(fun (x) {x*x}).FoldLeft(0.0, _+_)
}</
=={{header|NetRexx}}==
<
* program to sum the squares of a vector of fifteen numbers.
* translated from REXX
Line 1,846 ⟶ 2,100:
sum=sum + x**2 /*add its square to the sum. */
end
say "The sum of" n "elements for the V vector is:" sum</
{{out}}
<pre>The sum of 15 elements for the V vector is: 10650.25</pre>
=={{header|NewLISP}}==
<
-> 133
(apply + (map (fn(x) (* x x)) '()))
-> 0</
=={{header|Nim}}==
<
proc sumSquares[T: SomeNumber](a: openArray[T]): T =
Line 1,866 ⟶ 2,120:
let a2: seq[float] = @[]
echo a2, " → ", sumSquares(a2)</
{{out}}
<pre>[1, 2, 3, 4, 5] → 55
@[] → 0.0</pre>
=={{header|Oberon-2}}==
{{trans|Modula-3}}
<syntaxhighlight lang="oberon2">
MODULE SumSquares;
IMPORT Out;
VAR
A1:ARRAY 6 OF REAL;
PROCEDURE Init;
BEGIN
A1[0] := 3.0; A1[1] := 1.0; A1[2] := 4.0; A1[3] := 5.0; A1[4] := 9.0;
END Init;
PROCEDURE SumOfSquares(VAR arr:ARRAY OF REAL):REAL;
VAR
i:LONGINT;
sum:REAL;
BEGIN
sum := 0.0;
FOR i := 0 TO LEN(arr)-1 DO
sum := sum + arr[i] * arr[i]
END;
RETURN sum
END SumOfSquares;
BEGIN
Init;
Out.Real(SumOfSquares(A1),0);
Out.Ln
END SumSquares.
</syntaxhighlight>
{{out}}
<pre>1.32E+02
</pre>
=={{header|Objeck}}==
<
bundle Default {
class Sum {
Line 1,890 ⟶ 2,182:
}
}
</syntaxhighlight>
=={{header|OCaml}}==
<
<
=={{header|Octave}}==
<
sumsq = sum(a .^ 2);</
=={{header|Oforth}}==
<
=={{header|Ol}}==
<
(define (sum-of-squares l)
(fold + 0 (map * l l)))
Line 1,914 ⟶ 2,206:
(print (sum-of-squares '(1 2 3 4 5 6 7 8 9 10)))
; ==> 385
</syntaxhighlight>
=={{header|Order}}==
<
ORDER_PP(8to_lit(
8seq_fold(8plus, 0,
8seq_map(8fn(8X, 8times(8X, 8X)), 8seq(3, 1, 4, 1, 5, 9)))
))</
=={{header|Oz}}==
<
fun {SumOfSquares Xs}
for X in Xs sum:S do
Line 1,933 ⟶ 2,225:
end
in
{Show {SumOfSquares [3 1 4 1 5 9]}}</
=={{header|PARI/GP}}==
===Generic===
It is possible to apply a function, in this case ^2 to each element of an iterable and sum the result:
<
sum(i=1,#v,v[i]^2)
};</
===Specific===
For this particular task the product of a row matrix and its transpose is the sum of squares:
<
n=[2,5,23]
print(n*n~)
n=[]
print(n*n~)
</syntaxhighlight>
{{out}}
<pre>
Line 1,959 ⟶ 2,251:
{{libheader|Math}}
Example from the documenation of the run time library:
<
{ Program to demonstrate the SumOfSquares function. }
Line 1,977 ⟶ 2,269:
Writeln('Sum squares : ',SumOfSquares(ExArray):8:4);
Writeln('Sum squares (b) : ',SumOfSquares(@ExArray[1],100):8:4);
end.</
=={{header|Perl}}==
<
my $sum = 0;
$sum += $_**2 foreach @_;
Line 1,986 ⟶ 2,278:
}
print sum_of_squares(3, 1, 4, 1, 5, 9), "\n";</
or
<
sub sum_of_squares {
reduce { $a + $b **2 } 0, @_;
}
print sum_of_squares(3, 1, 4, 1, 5, 9), "\n";</
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">function</span> <span style="color: #000000;">sum_of_squares</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: #008080;">return</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sq_power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">))</span> <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">({{},{</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</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: #000000;">sum_of_squares</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
{0,133,385}
</pre>
=={{header|Phixmonti}}==
<
10 for 0 put endfor
Line 2,007 ⟶ 2,306:
endfor
drop print /# 385 #/</
=={{header|PHP}}==
<
function sum_squares(array $args) {
return array_reduce(
Line 2,016 ⟶ 2,315:
);
}
</syntaxhighlight>
In PHP5.3 support for anonymous functions was reworked. While the above code would still work, it is suggested to use
<
function sum_squares(array $args) {
return array_reduce($args, function($x, $y) {
Line 2,026 ⟶ 2,325:
}, 0);
}
</syntaxhighlight>
Usage for both examples: <code>sum_squares(array(1,2,3,4,5)); // 55</code>
=={{header|Picat}}==
<syntaxhighlight lang="picat">go =>
List = 1..666,
println(sum_squares(List)),
println(sum_squares([])),
nl.
sum_squares([]) = 0.
sum_squares(List) = sum([I*I : I in List]).</syntaxhighlight>
{{out}}
<pre>98691321
0</pre>
=={{header|PicoLisp}}==
<
-> 133
: (sum '((N) (* N N)) ())
-> 0</
=={{header|PL/0}}==
PL/0 has no arrays but they can be simulated.
<syntaxhighlight lang="pascal">
const maxlist = 5;
var sub, v, l1, l2, l3, l4, l5, sum;
procedure getelement;
begin
if sub = 1 then v := l1;
if sub = 2 then v := l2;
if sub = 3 then v := l3;
if sub = 4 then v := l4;
if sub = 5 then v := l5;
end;
procedure setelement;
begin
if sub = 1 then l1 := v;
if sub = 2 then l2 := v;
if sub = 3 then l3 := v;
if sub = 4 then l4 := v;
if sub = 5 then l5 := v;
end;
procedure sumofsquares;
begin
sub := 0;
sum := 0;
while sub < maxlist do begin
sub := sub + 1;
call getelement;
sum := sum + v * v
end;
end;
begin
sub := 0;
while sub < maxlist do begin
sub := sub + 1;
v := sub;
call setelement;
end;
call sumofsquares;
! sum;
end.
</syntaxhighlight>
{{out}}
<pre>
55
</pre>
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
declare A(10) float initial (10, 9, 8, 7, 6, 5, 4, 3, 2, 1);
put (sum(A**2));
</syntaxhighlight>
=={{header|PL/M}}==
{{works with|8080 PL/M Compiler}} ... under CP/M (or an emulator)
<syntaxhighlight lang="plm">
100H: /* CALCULATE THE SUM OF THE SQUARES OF THE ELEMENTS OF AN ARRAY */
/* CP/M BDOS SYSTEM CALL AND I/O ROUTINES */
BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
PR$CHAR: PROCEDURE( C ); DECLARE C BYTE; CALL BDOS( 2, C ); END;
PR$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S ); END;
PR$NL: PROCEDURE; CALL PR$CHAR( 0DH ); CALL PR$CHAR( 0AH ); END;
PR$NUMBER: PROCEDURE( N ); /* PRINTS A NUMBER IN THE MINIMUN FIELD WIDTH */
DECLARE N ADDRESS;
DECLARE V ADDRESS, N$STR ( 6 )BYTE, W BYTE;
V = N;
W = LAST( N$STR );
N$STR( W ) = '$';
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
DO WHILE( ( V := V / 10 ) > 0 );
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
END;
CALL PR$STRING( .N$STR( W ) );
END PR$NUMBER;
/* TASK */
/* RETURNS THE SUM OF THE SQUARES OF THE ARRAY AT A$PTR, UB MUST BE THE */
/* UB MUST BE THE UPPER-BOUND OF THE ARRAY */
SUM$OF$SQUARES: PROCEDURE( A$PTR, UB )ADDRESS;
DECLARE ( A$PTR, UB ) ADDRESS;
DECLARE ( I, SUM ) ADDRESS;
DECLARE A BASED A$PTR ( 0 )ADDRESS;
SUM = 0;
DO I = 0 TO UB;
SUM = SUM + ( A( I ) * A( I ) );
END;
RETURN SUM;
END SUM$OF$SQUARES;
DECLARE VALUES ( 5 )ADDRESS INITIAL( 1, 2, 3, 4, 5 );
CALL PR$NUMBER( SUM$OF$SQUARES( .VALUES, LAST( VALUES ) ) );
EOF
</syntaxhighlight>
=={{header|Plain English}}==
<
Start up.
Create a list.
Line 2,076 ⟶ 2,481:
Add the element's ratio times the element's ratio to the ratio.
Put the element's next into the element.
Repeat.</
{{out}}
<pre>
Line 2,084 ⟶ 2,489:
=={{header|Pop11}}==
<
lvars s = 0, j;
for j from 1 to length(v) do
Line 2,092 ⟶ 2,497:
enddefine;
sum_squares({1 2 3 4 5}) =></
=={{header|PostScript}}==
<syntaxhighlight lang="text">
/sqrsum{
/x exch def
Line 2,110 ⟶ 2,515:
sum ==
}def
</syntaxhighlight>
{{libheader|initlib}}
<
[3 1 4 1 5 9] 0 {dup * +} fold
</syntaxhighlight>
=={{header|PowerShell}}==
<
if ($a.Length -eq 0) {
return 0
Line 2,127 ⟶ 2,532:
return $x.Sum
}
}</
=={{header|Prolog}}==
Line 2,134 ⟶ 2,539:
=={{header|PureBasic}}==
<
ForEach base()
Sum + base()*base()
Next
ProcedureReturn Sum
EndProcedure</
=={{header|Python}}==
'''Using generator expression'''
<
# or
sum(x ** 2 for x in [1, 2, 3, 4, 5])
# or
sum(pow(x, 2) for x in [1, 2, 3, 4, 5])</
'''Functional versions:'''
<
sum(map(lambda x: x * x, [1, 2, 3, 4, 5]))
# or
Line 2,176 ⟶ 2,581:
reduce(add, powers_of_two)
# or using a bit more complex lambda
reduce(lambda a, x: a + x*x, [1, 2, 3, 4, 5])</
'''Using NumPy:'''
<
a = np.array([1, 2, 3, 4, 5])
np.sum(a ** 2)</
=={{header|Q}}==
<syntaxhighlight lang
=={{header|Quackery}}==
<
{{out}}
Line 2,211 ⟶ 2,616:
=={{header|R}}==
<
result <- sum(arr^2)</
=={{header|Racket}}==
<
#lang racket
(for/sum ([x #(3 1 4 1 5 9)]) (* x x))
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>say [+] map * ** 2, (3, 1, 4, 1, 5, 9);</syntaxhighlight>
If this expression seems puzzling, note that <code>* ** 2</code> is equivalent to <code>{$^x ** 2}</code>— the leftmost asterisk is not the multiplication operator but the <code>Whatever</code> star, which specifies currying behavior.
Line 2,230 ⟶ 2,633:
as a list infix is looser than comma in precedence but tighter than the reduction list operator:
<syntaxhighlight lang="raku"
=={{header|Raven}}==
<
0 $lst each dup * +
[ 1 2 3 4] sumOfSqrs "Sum of squares: %d\n" print</
{{out}}
<pre>Sum of squares: 30</pre>
=={{header|Red}}==
<syntaxhighlight lang="red">Red [
date: 2021-10-25
red-version: 0.6.4
description: "Find the sum of squares of a numeric vector"
]
sum-squares: function [
"Returns the sum of squares of all values in a block"
values [any-list! vector!]
][
result: 0
foreach value values [result: value * value + result]
result
]
print sum-squares []
print sum-squares [1 2 0.5]</syntaxhighlight>
{{out}}
<pre>
0
5.25
</pre>
=={{header|Refal}}==
<syntaxhighlight lang="refal">$ENTRY Go {
= <Prout <SquareSum 1 2 3 4 5>>
};
SquareSum {
= 0;
s.N e.rest = <+ <* s.N s.N> <SquareSum e.rest>>;
};</syntaxhighlight>
{{out}}
<pre>55</pre>
=={{header|ReScript}}==
With integers:
<syntaxhighlight lang="rescript">let sumOfSquares = (acc, item) => { acc + item * item }
Js.log(Js.Array2.reduce([10, 2, 4], sumOfSquares, 0))</syntaxhighlight>
With floats:
<syntaxhighlight lang="rescript">let sumOfSquares = (acc, item) => { acc +. item *. item }
Js.log(Js.Array2.reduce([10., 2., 4.], sumOfSquares, 0.))</syntaxhighlight>
=={{header|REXX}}==
===input from pgm===
<
numeric digits 100 /*allow 100─digit numbers; default is 9*/
v= -100 9 8 7 6 0 3 4 5 2 1 .5 10 11 12 /*define a vector with fifteen numbers.*/
Line 2,251 ⟶ 2,701:
end /*k*/ /* [↑] if vector is empty, then sum=0.*/
/*stick a fork in it, we're all done. */
say 'The sum of ' # " squared elements for the V vector is: " $</
'''output''' using an internal vector (list) of numbers:
<pre>
Line 2,258 ⟶ 2,708:
===input from C.L.===
<
numeric digits 100 /*allow 100─digit numbers; default is 9*/
parse arg v /*get optional numbers from the C.L. */
Line 2,269 ⟶ 2,719:
end /*until*/ /* [↑] if vector is empty, then sum=0.*/
say /*stick a fork in it, we're all done. */
say 'The sum of ' # " squared elements for the V vector is: " $</
'''output''' using a vector (list) of numbers from the command line:
<pre>
Line 2,278 ⟶ 2,728:
=={{header|Ring}}==
<
aList = [1,2,3,4,5]
see sumOfSquares(aList)
Line 2,288 ⟶ 2,738:
next
return sumOfSquares
</syntaxhighlight>
=={{header|
Zero-length vectors don't exist in RPL, so there's no need to tackle this case:
≪ DUP DOT ≫ '<span style="color:blue">∑SQV</span>' STO
If we really need zero-length objects, we can use lists:
≪ 0 SWAP
'''IF''' DUP SIZE '''THEN'''
1 OVER SIZE '''FOR''' j
DUP j GET SQ + '''NEXT'''
'''END''' DROP
≫ '<span style="color:blue">∑SQL</span>' STO
Using RPL 1993:
≪ '''IF''' DUP SIZE '''THEN''' SQ ∑LIST '''ELSE''' SIZE '''END''' ≫ '<span style="color:blue">∑SQL</span>' STO
[ 1 2 3 4 5 ] <span style="color:blue">∑SQV</span>
{ 1 2 3 4 5 } <span style="color:blue">∑SQL</span>
{ } <span style="color:blue">∑SQL</span>
{{out}}
<pre>
3: 55
2: 55
1: 0
</pre>
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">[3,1,4,1,5,9].sum(0){|x| x*x}</syntaxhighlight>
=={{header|Run BASIC}}==
<
print sumOfSquares(list$)
Line 2,306 ⟶ 2,775:
sumOfSquares = sumOfSquares + val(word$(sos$,i,","))^2
wend
END FUNCTION</
=={{header|Rust}}==
<
v.iter().fold(0., |sum, &num| sum + num*num)
}
Line 2,319 ⟶ 2,788:
let u : Vec<f64> = vec![];
println!("{}", sq_sum(&u));
}</
=={{header|Sather}}==
<
sqsum(s, e:FLT):FLT is
Line 2,337 ⟶ 2,806:
end;
end;</
=={{header|Scala}}==
Unfortunately there is no common "Numeric" class that Int and Double both extend, since Scala's number representation maps closely to Java's. Those concerned about precision can define a similar procedure for integers.
<
=={{header|Scheme}}==
<
(apply + (map * l l)))</
> (sum-of-squares (list 3 1 4 1 5 9))
Line 2,352 ⟶ 2,821:
=={{header|Seed7}}==
<
include "float.s7i";
Line 2,373 ⟶ 2,842:
writeln(squaredSum(list1));
writeln(squaredSum(list2));
end func;</
=={{header|Sidef}}==
<
var sum = 0;
vector.each { |n| sum += n**2 };
Line 2,383 ⟶ 2,852:
say sum_of_squares([]); # 0
say sum_of_squares([1,2,3]); # 14</
=={{header|Slate}}==
<
{} reduce: [|:x :y| y squared + x] ifEmpty: [0].</
=={{header|Smalltalk}}==
<
=={{header|SNOBOL4}}==
Line 2,399 ⟶ 2,868:
{{works with|CSnobol}}
<
ssq i = i + 1; ssq = ssq + (a<i> * a<i>) :s(sumsq)f(return)
ssq_end
Line 2,407 ⟶ 2,876:
loop i = i + 1; str len(p) span('0123456789') . a<i> @p :s(loop)
output = str ' -> ' sumsq(a)
end</
{{out}}
Line 2,414 ⟶ 2,883:
=={{header|SQL}}==
<
Note that this assumes that the values in our vector are named <code>x</code>.
Line 2,420 ⟶ 2,889:
=={{header|Standard ML}}==
<
<
=={{header|Stata}}==
=== Mata ===
<
sum(a:^2)
338350
Line 2,434 ⟶ 2,903:
0
sum(a:^2)
0</
=={{header|Swift}}==
<
return s.map{$0 * $0}.reduce(0, +)
}</
=={{header|Tailspin}}==
<syntaxhighlight lang="tailspin">
templates ssq
when <[](0)> do 0 !
otherwise $... -> $*$ -> ..=Sum&{of: :()} !
end ssq
[] -> ssq -> !OUT::write // outputs 0
[1..5] -> ssq -> !OUT::write // outputs 55
</syntaxhighlight>
=={{header|Tcl}}==
<
namespace path ::tcl::mathop
Line 2,452 ⟶ 2,932:
puts [sum_of_squares {1 2 3 4}]; # ==> 30
puts [sum_of_squares {}]; # ==> 0
</syntaxhighlight>
=={{header|Trith}}==
<
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
array="3'1'4'1'5'9",sum=0
Line 2,465 ⟶ 2,945:
ENDLOOP
PRINT sum
</syntaxhighlight>
{{out}}
<pre>
Line 2,473 ⟶ 2,953:
=={{header|UnixPipes}}==
<
(read B; res=$( expr $1 \* $1 ) ; test -n "$B" && expr $res + $B || echo $res)
}
Line 2,484 ⟶ 2,964:
(echo 3; echo 1; echo 4;echo 1;echo 5; echo 9) | fold</
=={{header|
<syntaxhighlight lang="sh">sum_squares () {
_r=0
for _n
do
: "$((_r += _n * _n))"
done
echo "$_r"
}
sum_squares 3 1 4 1 5 9</syntaxhighlight>
{{out}}
<pre>133</pre>
=={{header|Ursala}}==
Line 2,513 ⟶ 2,985:
maps the product function to all pairs, and then sums the
result by way of the reduction operator, -:.
<
ssq = sum:-0+ product*iip
Line 2,519 ⟶ 2,991:
#cast %n
main = ssq <21,12,77,0,94,23,96,93,72,72,79,24,8,50,9,93></
{{out}}
<pre>62223</pre>
=={{header|V}}==
<
[] sumsq
=0
[1 2 3] sumsq</
=14
=={{header|VBA}}==
<
Debug.Print WorksheetFunction.SumSq([{1,2,3,4,5,6,7,8,9,10}])
End Sub</
<pre> 385 </pre>
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
Function sum_of_squares(arr)
If UBound(arr) = -1 Then
Line 2,550 ⟶ 3,022:
WScript.StdOut.WriteLine sum_of_squares(Array(1,2,3,4,5))
WScript.StdOut.WriteLine sum_of_squares(Array())
</syntaxhighlight>
{{Out}}
Line 2,559 ⟶ 3,031:
=={{header|Visual Basic .NET}}==
<
Private Shared Function sumsq(ByVal i As ICollection(Of Integer)) As Integer
If i Is Nothing OrElse i.Count = 0 Then
Line 2,596 ⟶ 3,068:
End Function
</syntaxhighlight>
{{out}}
<pre>
Line 2,617 ⟶ 3,089:
SumOfSquares(15) = 1240
SumOfSquares(16) = 1496
</pre>
=={{header|VTL-2}}==
<syntaxhighlight lang="vtl2">
1000 :1)=1
1010 :2)=2
1020 :3)=3
1030 :4)=4
1040 :5)=5
1050 L=5
1060 #=2000
1070 ?=S
1080 #=9999
2000 R=!
2010 S=0
2020 I=1
2030 #=I<L+(I=L)=0*R
2040 S=I*I+S
2050 I=I+1
2060 #=2030
</syntaxhighlight>
{{out}}
<pre>
55
</pre>
=={{header|Wortel}}==
<
<
As a function:
<syntaxhighlight lang
Iterative function:
<
=={{header|Wren}}==
<
var v = [1, 2, 3, -1, -2, -3]
System.print("Vector : %(v)")
System.print("Sum of squares : %(sumSquares.call(v))")</
{{out}}
Line 2,642 ⟶ 3,138:
=={{header|XLISP}}==
The task specification calls for a function that takes a numeric vector. If you want a function that takes a linked list (which would be more idiomatic), just extract the inner function <tt>SUMSQ</tt> and use that instead of <tt>SUM-OF-SQUARES</tt>.
<
(defun sumsq (xs)
(if (null xs)
Line 2,655 ⟶ 3,151:
(print `(the sum of the squares of the first seven prime numbers is ,(sum-of-squares first-seven-primes)))
(print `(the sum of the squares of no numbers at all is ,(sum-of-squares zero-length-vector)))</
{{out}}
<pre>(THE SUM OF THE SQUARES OF THE FIRST SEVEN PRIME NUMBERS IS 666)
Line 2,661 ⟶ 3,157:
=={{header|XPL0}}==
<
func SumSq(V, L);
Line 2,673 ⟶ 3,169:
[IntOut(0, SumSq([1,2,3,4,5,6,7,8,9,10], 10)); CrLf(0);
IntOut(0, SumSq([0], 0)); CrLf(0); \zero-length vector "[]" doesn't compile
]</
{{out}}
Line 2,682 ⟶ 3,178:
=={{header|zkl}}==
<
T(3,1,4,1,5,9).reduce(fcn(p,n){ p + n*n },0.0) //-->133.0
[1..5].reduce(fcn(p,n){ p + n*n },0) //-->55</
|