Sum of squares: Difference between revisions

Content added Content deleted

Inline

Revision as of 21:35, 9 May 2022

Task

Write a program to find the sum of squares of a numeric vector.

The program should work on a zero-length vector (with an answer of 0).

Related task

Mean

0815

Output:

0
28A

11l

<lang 11l>print(sum([1, 2, 3, 4, 5].map(x -> x^2)))</lang>

Output:

360 Assembly

<lang 360asm>* Sum of squares 27/08/2015 SUMOFSQR CSECT

        USING  SUMOFSQR,R12
        LR     R12,R15
        LA     R7,A               a(1)
        SR     R6,R6              sum=0
        LA     R3,1               i=1

LOOPI CH R3,N do i=1 to hbound(a)

        BH     ELOOPI
        L      R5,0(R7)           a(i)
        M      R4,0(R7)           a(i)*a(i)
        AR     R6,R5              sum=sum+a(i)**2
        LA     R7,4(R7)           next a
        LA     R3,1(R3)           i=i+1
        B      LOOPI              end i

ELOOPI XDECO R6,PG+23 edit sum

        XPRNT  PG,80
        XR     R15,R15
        BR     R14

A DC F'1',F'2',F'3',F'4',F'5',F'6',F'7',F'8',F'9',F'10' PG DC CL80'The sum of squares is: ' N DC AL2((PG-A)/4)

        YREGS
        END    SUMOFSQR</lang>

Output:

The sum of squares is:          385

<lang asm> ;;; Sum of squares cpu 8086 bits 16 section .text org 100h jmp demo ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Calculate the sum of the squares of the array in SI. ;;; The array should contain 16-bit unsigned integers. ;;; The output will be 32-bit. ;;; Input: (DS:)SI = array, CX = array length ;;; Output: DX:AX = sum of squares ;;; Registers used: AX,BX,CX,DX,SI,DI sumsqr: xor bx,bx ; Keep accumulator in BX:DI. xor di,di ; (So zero it out first) and cx,cx ; Counter register 0? "Program should work jz .done ; on a zero-length vector" .loop: mov ax,[si] ; Grab value from array mul ax ; Calculate square of value (into DX:AX) add di,ax ; Add low 16 bits to accumulator adc bx,dx ; Add high 16 bits, plus carry inc si ; Point to next value inc si loop .loop ; Next value in array .done: mov ax,di ; Return the value in DX:AX as is tradition mov dx,bx ret ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; Demo: use the subroutine to calculate the sum of squares ;;; in the included array, and show the result demo: mov si,array mov cx,arrlen call sumsqr ;;; Print the return value in DX:AX as a decimal number ;;; (Note: max supported value 655359 - this is a limitation ;;; of this rudimentary output code, not of the sum of squares ;;; routine.) mov di,outstr_end mov cx,10 .decloop: div cx dec di add dl,'0' mov [di],dl xor dx,dx and ax,ax jnz .decloop mov dx,di mov ah,9 int 21h ret section .data outstr: db '######' ; Placeholder for decimal output 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</lang>

ACL2

<lang Lisp>(defun sum-of-squares (xs)

  (if (endp xs)
      0
      (+ (* (first xs) (first xs))
         (sum-of-squares (rest xs)))))</lang>

Action!

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

Output:

Screenshot from Atari 8-bit computer

[1 2 3 4 5]->55

[10 20 30 40 50 60 70 80 90]->28500

[11]->121

[]->0

ActionScript

<lang ActionScript>function sumOfSquares(vector:Vector.<Number>):Number { var sum:Number = 0; for(var i:uint = 0; i < vector.length; i++) sum += vector[i]*vector[i]; return sum; }</lang>

Ada

<lang ada>with Ada.Text_IO; use Ada.Text_IO;

procedure Test_Sum_Of_Squares is

  type Float_Array is array (Integer range <>) of Float;

  function Sum_Of_Squares (X : Float_Array) return Float is
     Sum : Float := 0.0;
  begin
     for I in X'Range loop
        Sum := Sum + X (I) ** 2;
     end loop;
     return Sum;
  end Sum_Of_Squares;

begin

  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;</lang>

Output:

 0.00000E+00
 1.33000E+02

Aime

<lang aime>real squaredsum(list l) {

   integer i;
   real s;

   s = 0;
   i = -~l;
   while (i) {
       s += sq(l[i += 1]);
   }

s;

}

integer main(void) {

   list l;

   l = list(0, 1, 2, 3);

   o_form("~\n", squaredsum(l));
   o_form("~\n", squaredsum(list()));
   o_form("~\n", squaredsum(list(.5, -.5, 2)));

0;

}</lang>

Output:

14
0
4.5

ALGOL 68

Works with: ALGOL 68 version Revision 1 - 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) - tested with release 1.8-8d

The computation can be written as a loop. <lang algol68>PROC sum of squares = ([]REAL argv)REAL:(

 REAL sum := 0;
 FOR i FROM LWB argv TO UPB argv DO
   sum +:= argv[i]**2
 OD;
 sum

); test:(

 printf(($g(0)l$,sum of squares([]REAL(3, 1, 4, 1, 5, 9))));

)</lang>

Output:

Another implementation could define a procedure (proc) or operator (op) called map.

Translation of: python

<lang algol68>[]REAL data = (3, 1, 4, 1, 5, 9);

PROC map = ( PROC(REAL)REAL func, []REAL argv)REAL:

   ( REAL out:=0; FOR i FROM LWB argv TO UPB argv DO out:=func(argv[i]) OD; out);

test:(

 REAL sum := 0;
 printf(($xg(0)l$, map ( ((REAL argv)REAL: sum +:= argv ** 2), data) ));

 PRIO MAP = 5; # the same priority as the operators <, =<, >=, & > maybe... #
 OP MAP = ( PROC(REAL)REAL func, []REAL argv)REAL:
   ( REAL out:=0; FOR i FROM LWB argv TO UPB argv DO out:=func(argv[i]) OD; out);

 sum := 0;
 printf(($g(0)l$, ((REAL argv)REAL: sum +:= argv ** 2) MAP data ))

)</lang>

Output:

133
133

Works with: ALGOL 68 version Revision 1 - requires the Currying extension

Works with: ALGOL 68G version Any - tested with release a68g-2.8.3

The computation can be written as a generator. <lang algol68>#!/usr/bin/a68g --script #

-*- coding: utf-8 -*- #

MODE YIELDREAL = PROC(REAL)VOID; MODE GENREAL = PROC(YIELDREAL)VOID;

PROC gen real of vector = ([]REAL data, YIELDREAL yield)VOID:

 FOR i FROM LWB data TO UPB data DO yield(data[i]) OD;

PROC real sum sq of gen = (GENREAL gen real)REAL: (

 REAL sum:=0;

FOR REAL value IN # gen real(#) DO (#

    (REAL value)VOID:(
      sum+:=value**2

OD #));

sum

);

PROC real sum map of gen = (PROC(REAL)REAL func, GENREAL gen real)REAL: (

 REAL sum:=0;

FOR REAL value IN # gen real(#) DO (#

    (REAL value)VOID:(
      sum+:=func(value)

OD #));

sum

);

OP GEN = ([]REAL array)GENREAL:gen real of vector(array,);

OP (GENREAL #gen real#)REAL SUMSQ = real sum sq of gen;

PRIO SUMMAP = 5; OP (PROC(REAL)REAL #func#, GENREAL #gen real#)REAL SUMMAP = real sum map of gen;

test:(

 []REAL data = (3, 1, 4, 1, 5, 9);

Permutations of the above routines #

 printf(($"real sum sq GEN: "g(0)l$, real sum sq of gen(GEN data)));
 printf(($"real sum sq real gen: "g(0)l$, real sum sq of gen(gen real of vector(data,))));
 printf(($"real sum map real gen: "g(0)l$, real sum map of gen(((REAL x)REAL: x*x),gen real of vector(data,))));
 printf(($"SUMSQ real gen: "g(0)l$, SUMSQ gen real of vector(data,)));
 printf(($"SUMSQ GEN: "g(0)l$, SUMSQ GEN data));
 printf(($"sq SUMMAP GEN: "g(0)l$, ((REAL x)REAL: x*x)SUMMAP GEN data))

)</lang>

Output:

real sum sq GEN: 133
real sum sq real gen: 133
real sum map real gen: 133
SUMSQ real gen: 133
SUMSQ GEN: 133
sq SUMMAP GEN: 133

ALGOL W

<lang algolw>begin

   % procedure to sum the elements of a vector. As the procedure can't find %
   % the bounds of the array for itself, we pass them in lb and ub          %
   real procedure sumSquares ( real    array vector ( * )
                             ; integer value lb
                             ; integer value ub
                             ) ;
   begin
       real sum;
       sum := 0;
       for i := lb until ub do sum := sum + ( vector( i ) * vector( i ) );
       sum
   end sumOfSquares ;

   % test the sumSquares procedure                                          %
   real array numbers ( 1 :: 5 );
   for i := 1 until 5 do numbers( i ) := i;
   r_format := "A"; r_w := 10; r_d := 1; % set fixed point output           %
   write( sumSquares( numbers, 1, 5 ) );

end.</lang>

Alore

<lang Alore>def sum_squares(a)

  var sum = 0
  for i in a
     sum = sum + i**2
  end
  return sum

end

WriteLn(sum_squares([3,1,4,1,5,9])) end</lang>

APL

<lang apl> square_sum←{+/⍵*2}

     square_sum 1 2 3 4 5

55

     square_sum ⍬ ⍝The empty vector

0</lang>

AppleScript

Two ways of composing a sumOfSquares function: <lang AppleScript>------ TWO APPROACHES – SUM OVER MAP, AND DIRECT FOLD ----

-- sumOfSquares :: Num a => [a] -> a on sumOfSquares(xs)

   script squared
       on |λ|(x)
           x ^ 2
       end |λ|
   end script
   
   sum(map(squared, xs))

end sumOfSquares

-- sumOfSquares2 :: Num a => [a] -> a on sumOfSquares2(xs)

   script plusSquare
       on |λ|(a, x)
           a + x ^ 2
       end |λ|
   end script
   
   foldl(plusSquare, 0, xs)

end sumOfSquares2

TEST -------------------------

on run

   set xs to [3, 1, 4, 1, 5, 9]
   
   {sumOfSquares(xs), sumOfSquares2(xs)}
   
   -- {133.0, 133.0}

end run

GENERIC FUNCTIONS -------------------

-- foldl :: (a -> b -> a) -> a -> [b] -> a on 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 tell

end foldl

-- map :: (a -> b) -> [a] -> [b] on map(f, xs)

   tell mReturn(f)
       set lng to length of xs
       set lst to {}
       repeat with i from 1 to lng
           set end of lst to |λ|(item i of xs, i, xs)
       end repeat
       return lst
   end tell

end map

-- Lift 2nd class handler function into 1st class script wrapper -- mReturn :: Handler -> Script on mReturn(f)

   if class of f is script then
       f
   else
       script
           property |λ| : f
       end script
   end if

end mReturn

-- sum :: Num a => [a] -> a on sum(xs)

   script add
       on |λ|(a, b)
           a + b
       end |λ|
   end script
   
   foldl(add, 0, xs)

end sum</lang>

Output:

Arturo

<lang rebol>arr: 1..10

print sum map arr [x][x^2]</lang>

Output:

Astro

Asymptote

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

AutoHotkey

<lang autohotkey>list = 3 1 4 1 5 9 Loop, Parse, list, %A_Space%

sum += A_LoopField**2

MsgBox,% sum</lang>

AWK

Vectors are read, space-separated, from stdin; sum of squares goes to stdout. The empty line produces 0. <lang awk>$ awk '{s=0;for(i=1;i<=NF;i++)s+=$i*$i;print s}' 3 1 4 1 5 9 133

0</lang>

BASIC

Works with: QBasic

Assume the numbers are in an array called a. <lang qbasic>sum = 0 FOR I = LBOUND(a) TO UBOUND(a)

 sum = sum + a(I) ^ 2

NEXT I PRINT "The sum of squares is: " + sum</lang>

BaCon

<lang freebasic>' Sum of squares FUNCTION ss(int arr[], NUMBER elem)

   sum = 0
   FOR i = 0 TO elem - 1
       sum = sum + POW(arr[i], 2)
   NEXT
   RETURN sum

END FUNCTION

' 1 to 10 in the test vector, or 1 to -s n option = CMDLINE("s:") IF option = ASC("s") THEN

   elem = VAL(ARGUMENT$)

ELSE

   elem = 10

END IF

DECLARE vector TYPE int ARRAY elem FOR i = 0 TO elem - 1

   vector[i] = i + 1

NEXT PRINT ss(vector, elem)</lang>

Output:

prompt$ ./sumsquares
385
prompt$ ./sumsquares -s 1000
333833500

BASIC256

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

BBC BASIC

BBC BASIC cannot have a zero-length array. <lang bbcbasic> DIM vector(5)

     vector() = 1, 2, 3, 4, 5, 6
     
     PRINT "Sum of squares = " ; MOD(vector()) ^ 2</lang>

Output:

Sum of squares = 91

IS-BASIC

<lang IS-BASIC>100 INPUT PROMPT "Number of elements: ":N 110 NUMERIC A(1 TO N) 120 FOR I=1 TO N 130 PRINT I;:INPUT PROMPT ". = ":A(I) 140 NEXT 150 PRINT "The sum of squares is:";SQ(A) 160 DEF SQ(REF T) 170 LET S=0 180 FOR I=LBOUND(T) TO UBOUND(T) 190 LET S=S+T(I)^2 200 NEXT 210 LET SQ=S 220 END DEF</lang>

Yabasic

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

bc

<lang bc>define s(a[], n) {

   auto i, s
   
   for (i = 0; i < n; i++) {
       s += a[i] * a[i]
   }
   
   return(s)

}</lang>

BCPL

<lang bcpl>get "libhdr"

let sumsquares(v, len) =

   len=0 -> 0,
   !v * !v + sumsquares(v+1, len-1)

let start() be $( let vector = table 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

   writef("%N*N", sumsquares(vector, 10))

$)</lang>

Output:

BQN

Similar to the BQN entry in Sum of a series. <lang bqn>SSq ← +´√⁼

•Show SSq 1‿2‿3‿4‿5 •Show SSq ⟨⟩</lang> <lang>55 0</lang>

Bracmat

<lang bracmat>( ( sumOfSquares

 =   sum component
   .   0:?sum
     &   whl
       ' ( !arg:%?component ?arg
         & !component^2+!sum:?sum
         )
     & !sum
 )

& out$(sumOfSquares$(3 4)) & out$(sumOfSquares$(3 4 i*5)) & out$(sumOfSquares$(a b c)) );</lang>

Output:

25
0
a^2+b^2+c^2

Brat

<lang brat>p 1.to(10).reduce 0 { res, n | res = res + n ^ 2 } #Prints 385</lang>

C

<lang c>#include <stdio.h>

double squaredsum(double *l, int e) {

  int i; double sum = 0.0;
  for(i = 0 ; i < e ; i++) sum += l[i]*l[i];
  return sum;

}

int main() {

  double list[6] = {3.0, 1.0, 4.0, 1.0, 5.0, 9.0};
  
  printf("%lf\n", squaredsum(list, 6));
  printf("%lf\n", squaredsum(list, 0));
  /* the same without using a real list as if it were 0-element long */
  printf("%lf\n", squaredsum(NULL, 0));
  return 0;

}</lang>

C#

<lang csharp>using System; using System.Collections.Generic; using System.Linq;

class Program {

   static int SumOfSquares(IEnumerable<int> list)
   {
       return list.Sum(x => x * x);
   }
   static void Main(string[] args)
   {
       Console.WriteLine(SumOfSquares(new int[] { 4, 8, 15, 16, 23, 42 })); // 2854
       Console.WriteLine(SumOfSquares(new int[] { 1, 2, 3, 4, 5 })); // 55
       Console.WriteLine(SumOfSquares(new int[] { })); // 0
   }

}</lang>

C++

Using accumulate

<lang cpp>#include <iostream>

include <numeric>
include <vector>

double add_square(double prev_sum, double new_val) {

 return prev_sum + new_val*new_val;

}

double vec_add_squares(std::vector<double>& v) {

 return std::accumulate(v.begin(), v.end(), 0.0, add_square);

}

int main() {

 // first, show that for empty vectors we indeed get 0
 std::vector<double> v; // empty
 std::cout << vec_add_squares(v) << std::endl;

 // now, use some values
 double data[] = { 0, 1, 3, 1.5, 42, 0.1, -4 };
 v.assign(data, data+7);
 std::cout << vec_add_squares(v) << std::endl;
 return 0;

}</lang>

Using inner_product

<lang cpp>#include <iostream>

include <numeric>
include <vector>

int main() {

 // first, show that for empty vectors we indeed get 0
 std::vector<double> v; // empty
 std::cout << std::inner_product(begin(v), end(v), begin(v), 0.0) << std::endl;
 
 // now, use some values
 double data[] = { 0, 1, 3, 1.5, 42, 0.1, -4 };
 v.assign(data, data+7);
 std::cout << std::inner_product(begin(v), end(v), begin(v), 0.0) << std::endl;
 return 0;

}</lang>

Using Boost.Lambda

Library: Boost.Lambda

<lang cpp>#include <numeric>

include <vector>
include "boost/lambda/lambda.hpp"

double vec_add_squares(std::vector<double>& v) {

 using namespace boost::lambda;

 return std::accumulate(v.begin(), v.end(), 0.0, _1 + _2 * _2);

}</lang>

Chef

<lang Chef>Sum of squares.

First input is length of vector, then rest of input is vector.

Ingredients. 1 g eggs 0 g bacon

Method. Put bacon into the 1st mixing bowl. Take eggs from refrigerator. Square the eggs. Take bacon from refrigerator. Put bacon into 2nd mixing bowl. Combine bacon into 2nd mixing bowl. Fold bacon into 2nd mixing bowl. Add the bacon into the 1st mixing bowl. Ask the eggs until squared. Pour contents of the 1st mixing bowl into the 1st baking dish.

Serves 1.

</lang>

Clojure

<lang clojure>(defn sum-of-squares [v]

 (reduce #(+ %1 (* %2 %2)) 0 v))</lang>

CLU

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

Output:

0
55
1764

CoffeeScript

<lang coffeescript> sumOfSquares = ( list ) ->

   list.reduce (( sum, x ) -> sum + ( x * x )), 0

</lang>

Common Lisp

<lang lisp>(defun sum-of-squares (vector)

 (loop for x across vector sum (expt x 2)))</lang>

Cowgol

<lang cowgol>include "cowgol.coh"; include "argv.coh";

Sum of squares

sub sumsquare(vec: [int32], len: intptr): (out: uint32) is

   out := 0;    
   while len > 0 loop
       var cur := [vec];
       # make positive first so we can use extra range of uint32
       if cur < 0 then cur := -cur; end if;
       out := out + cur as uint32 * cur as uint32;
       vec := @next vec;
       len := len - 1;
   end loop;

end sub;

Read array from command line, allowing empty line (giving 0)

var nums: int32[128]; var len: @indexof nums := 0;

ArgvInit(); loop

   var argmt := ArgvNext(); # read number
   if argmt == (0 as [uint8]) then
       break; # stop when no more numbers
   end if;
   
   var dummy: [uint8];
   (nums[len], dummy) := AToI(argmt);
   len := len + 1;

end loop;

Print sum of squares of numbers

print_i32(sumsquare(&nums[0], len as intptr)); print_nl();</lang>

Output:

$ ./sumsq.386
0
$ ./sumsq.386 {1..30}
9455
$ ./sumsq.386 512
262144

Crystal

<lang Ruby> def sum_squares(a)

   a.map{|e| e*e}.sum()

end

puts sum_squares([1, 2, 3])

=> 14

</lang>

D

Iterative Version

<lang d>T sumSquares(T)(T[] a) pure nothrow @safe @nogc {

   T sum = 0;
   foreach (e; a)
       sum += e ^^ 2;
   return sum;

}

void main() {

   import std.stdio: writeln;

   [3.1, 1.0, 4.0, 1.0, 5.0, 9.0].sumSquares.writeln;

}</lang>

Output:

133.61

Polymorphic Functional Style

<lang d>import std.stdio, std.algorithm, std.traits, std.range;

auto sumSquares(Range)(Range data) pure nothrow @safe @nogc {

   return reduce!q{a + b ^^ 2}(ForeachType!Range(0), data);

}

void main() {

   immutable items = [3.1, 1.0, 4.0, 1.0, 5.0, 9.0];
   items.sumSquares.writeln;
   10.iota.sumSquares.writeln;

}</lang>

Output:

133.61
285

Dart

Iterative Version

<lang d>sumOfSquares(list) {

 var sum=0;
 list.forEach((var n) { sum+=(n*n); });
 return sum;

}

main() {

 print(sumOfSquares([]));
 print(sumOfSquares([1,2,3]));
 print(sumOfSquares([10]));

}</lang>

Output:

0
14
100

Functional Style Version

<lang d>num sumOfSquares(List<num> l) => l.map((num x)=>x*x) .fold(0, (num p,num n)=> p + n);

void main(){

 print(sumOfSquares([]));
 print(sumOfSquares([1,2,3]));
 print(sumOfSquares([10]));

}</lang>

Output:

0
14
100

Delphi

Delphi has standard SumOfSquares function in Math unit: <lang Delphi>program SumOfSq;

{$APPTYPE CONSOLE}

uses Math;

type

 TDblArray = array of Double;

var

 A: TDblArray;

begin

 Writeln(SumOfSquares([]):6:2);            //  0.00
 Writeln(SumOfSquares([1, 2, 3, 4]):6:2);  // 30.00
 A:= nil;
 Writeln(SumOfSquares(A):6:2);             //  0.00
 A:= TDblArray.Create(1, 2, 3, 4);
 Writeln(SumOfSquares(A):6:2);             // 30.00
 Readln;

end.</lang>

Draco

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

Output:

0
1764
55

E

<lang e>def sumOfSquares(numbers) {

   var sum := 0
   for x in numbers {
       sum += x**2
   }
   return sum

}</lang>

Eiffel

<lang Eiffel> class APPLICATION

create make

feature -- Initialization

make local a: ARRAY [INTEGER] do a := <<1, -2, 3>> print ("%NSquare sum of <<1, 2, 3>>: " + sum_of_square (a).out)

a := <<>> print ("%NSquare sum of <<>>: " + sum_of_square (a).out) end

feature -- Access

sum_of_square (a: ITERABLE [INTEGER]): NATURAL -- sum of square of each items do Result := 0 across a as it loop Result := Result + (it.item * it.item).as_natural_32 end end

end </lang>

Elena

ELENA 5.0 : <lang elena>import system'routines; import extensions;

SumOfSquares(list)

   = list.selectBy:(x => x * x).summarize(new Integer());

public program() {

   console 
       .printLine(SumOfSquares(new int[]{4, 8, 15, 16, 23, 42}))
       .printLine(SumOfSquares(new int[]{1, 2, 3, 4, 5}))
       .printLine(SumOfSquares(Array.MinValue))

}</lang>

Output:

2854
55
0

Elixir

<lang elixir>iex(1)> Enum.reduce([3,1,4,1,5,9], 0, fn x,sum -> sum + x*x end) 133</lang>

Emacs Lisp

<lang Lisp>(defun sum-of-squares (numbers)

 (apply #'+ (mapcar (lambda (k) (* k k)) numbers)))

(sum-of-squares (number-sequence 0 3)) ;=> 14</lang>

Erlang

<lang erlang>lists:foldl(fun(X, Sum) -> X*X + Sum end, 0, [3,1,4,1,5,9]).</lang>

Euphoria

<lang euphoria>function SumOfSquares(sequence v)

   atom sum
   sum = 0
   for i = 1 to length(v) do
       sum += v[i]*v[i]
   end for
   return sum

end function</lang>

Excel

To find the sum of squares of values from A1 to A10, type in any other cell :

<lang Excel> =SUMSQ(A1:A10) </lang>

The above expression will return zero if there are no values in any cell.

<lang> 12 3 5 23 13 67 15 9 4 2

5691 </lang>

F#

<lang fsharp>[1 .. 10] |> List.fold (fun a x -> a + x * x) 0 [|1 .. 10|] |> Array.fold (fun a x -> a + x * x) 0</lang>

Factor

<lang factor>USE: math sequences ;

sum-of-squares ( seq -- n ) [ sq ] map-sum ;

{ 1.0 2.0 4.0 8.0 16.0 } sum-of-squares</lang>

FALSE

Fantom

<lang fantom> class SumSquares {

 static Int sumSquares (Int[] numbers)
 {
   Int sum := 0
   numbers.each |n| { sum += n * n }
   return sum
 }

 public static Void main () 
 {
   Int[] n := [,]
   echo ("Sum of squares of $n = ${sumSquares(n)}")
   n = [1,2,3,4,5]
   echo ("Sum of squares of $n = ${sumSquares(n)}")
 }

} </lang>

Fish

<lang Fish>v \0& >l?!v:*&+&

   >&n;</lang>

Forth

<lang forth>: fsum**2 ( addr n -- f )

 0e
 dup 0= if 2drop exit then
 floats bounds do
   i f@ fdup f* f+
 1 floats +loop ;

create test 3e f, 1e f, 4e f, 1e f, 5e f, 9e f, test 6 fsum**2 f. \ 133.</lang>

Fortran

In ISO Fortran 90 orlater, use SUM intrinsic and implicit element-wise array arithmetic: <lang fortran>real, dimension(1000) :: a = (/ (i, i=1, 1000) /) real, pointer, dimension(:) :: p => a(2:1) ! pointer to zero-length array real :: result, zresult

result = sum(a*a) ! Multiply array by itself to get squares

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

FreeBASIC

<lang freebasic>' FB 1.05.0 Win64

Function SumSquares(a() As Double) As Double

 Dim As Integer length = UBound(a) - LBound(a) + 1
 If length = 0 Then Return 0.0
 Dim As Double sum = 0.0
 For i As Integer = LBound(a) To UBound(a)
   sum += a(i) * a(i)
 Next
 Return sum

End Function

Dim a(5) As Double = {1.0, 2.0, 3.0, -1.0, -2.0, -3.0} Dim sum As Double = SumSquares(a()) Print "The sum of the squares is"; sum Print Print "Press any key to quit" Sleep</lang>

Output:

The sum of the squares is 28

Frink

<lang frink> f = {|x| x^2} // Anonymous function which squares its argument a = [1,2,3,5,7] println[sum[map[f,a], 0]] </lang>

Fōrmulæ

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website, However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.

In this page you can see the program(s) related to this task and their results.

GAP

<lang gap># Just multiplying a vector by itself yields the sum of squares (it's an inner product)

It's necessary to check for the empty vector though

SumSq := function(v) if Size(v) = 0 then return 0; else return v*v; fi; end;</lang>

GEORGE

<lang GEORGE>read (n) print ; 0 1, n rep (i)

  read print dup mult +
  ]

print</lang> data

results:

 1.100000000000000E+0001  << number of values (11)
 8.000000000000000        << 11 data
 1.200000000000000E+0001
 1.500000000000000E+0001
 6.000000000000000      
 2.500000000000000E+0001
 1.900000000000000E+0001
 3.300000000000000E+0001
 2.700000000000000E+0001
 3.000000000000000      
 3.700000000000000E+0001
 4.000000000000000      
 4.667000000000000E+0003  << sum of squares

Go

Implementation

<lang go>package main

import "fmt"

var v = []float32{1, 2, .5}

func main() {

   var sum float32
   for _, x := range v {
       sum += x * x
   }
   fmt.Println(sum)

}</lang>

Output:

5.25

Library

<lang go>package main

import (

   "fmt"

   "github.com/gonum/floats"

)

var v = []float64{1, 2, .5}

func main() {

   fmt.Println(floats.Dot(v, v))

}</lang>

Output:

5.25

Golfscript

<lang golfscript>{0\{.*+}%}:sqsum;

usage example

[1 2 3]sqsum puts</lang>

Groovy

<lang groovy>def array = 1..3

// square via multiplication def sumSq = array.collect { it * it }.sum() println sumSq

// square via exponentiation sumSq = array.collect { it ** 2 }.sum()

println sumSq</lang>

Output:

14
14

Haskell

Three approaches: <lang haskell>versions :: [[Int] -> Int] versions =

 [ sum . fmap (^ 2)      -- ver 1
 , sum . ((^ 2) <$>)     -- ver 2
 , foldr ((+) . (^ 2)) 0 -- ver 3
 ]

main :: IO () main =

 mapM_ print ((`fmap` [[3, 1, 4, 1, 5, 9], [1 .. 6], [], [1]]) <$> versions)</lang>

Output:

[133,91,0,1]
[133,91,0,1]
[133,91,0,1]

Icon and Unicon

<lang icon>procedure main()

  local lst
  lst := []
  #Construct a simple list and pass it to getsum
  every put(lst,seq()\2)
  write(getsum(lst))

end

procedure getsum(lst)

  local total
  total := 0
  every total +:= !lst ^ 2
  return total

end</lang>

IDL

<lang idl>print,total(array^2)</lang>

Inform 7

<lang inform7>Sum Of Squares is a room.

To decide which number is the sum of (N - number) and (M - number) (this is summing): decide on N + M.

To decide which number is (N - number) squared (this is squaring): decide on N * N.

To decide which number is the sum of squares of (L - list of numbers): decide on the summing reduction of squaring applied to L.

When play begins: say the sum of squares of {}; say line break; say the sum of squares of {1, 2, 3}; end the story.</lang>

Io

<lang io>list(3,1,4,1,5,9) map(squared) sum</lang>

J

That is, sum composed with square. The verb also works on higher-ranked arrays. For example:

<lang j> ss 3 1 4 1 5 9 133

  ss $0           NB. $0 is a zero-length vector

0

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

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.

<lang j>ss1=: 3 : 0

z=. 0
for_i. i.#y do. z=. z+*:i{y end.

)

  ss1 3 1 4 1 5 9

133

  ss1 $0

0

  ss1 x

9.09516 5.19512 5.84173 6.6916</lang>

Java

Works with: Java version 1.5+

<lang java5>public class SumSquares {

public static void main(final String[] args)
{
 double sum = 0;
 int[] nums = {1,2,3,4,5};
 for (int i : nums)
  sum += i * i;
 System.out.println("The sum of the squares is: " + sum);
}

}</lang>

JavaScript

ES5

<lang javascript>function sumsq(array) {

 var sum = 0;
 var i, iLen;

 for (i = 0, iLen = array.length; i < iLen; i++) {
   sum += array[i] * array[i];
 }
 return sum;

}

alert(sumsq([1,2,3,4,5])); // 55</lang>

An alternative using a while loop and Math.pow

<lang javascript>function sumsq(array) {

 var sum = 0, 
     i = array.length;

 while (i--) sum += Math.pow(array[i], 2);

 return sum;

}

alert(sumsq([1,2,3,4,5])); // 55</lang>

Library: Functional

<lang javascript>Functional.reduce("x+y*y", 0, [1,2,3,4,5])</lang>

map (JS 1.6) and reduce (JS 1.8)

<lang javascript>[3,1,4,1,5,9].map(function (n) { return Math.pow(n,2); }).reduce(function (sum,n) { return sum+n; });</lang>

ES6

Two ways of composing a sumOfSquares function <lang JavaScript>(() => {

   'use strict';

   // sumOfSquares :: Num a => [a] -> a
   const sumOfSquares = xs =>
       sum(xs.map(squared));

   // sumOfSquares2 :: Num a => [a] -> a
   const sumOfSquares2 = xs =>
       xs.reduce((a, x) => a + squared(x), 0);

   // ---------------------- TEST -----------------------
   const main = () => [
       sumOfSquares,
       sumOfSquares2
   ].map(
       f => f([3, 1, 4, 1, 5, 9])
   ).join('\n');

   // --------------------- GENERIC ---------------------

   // squared :: Num a => a -> a
   const squared = x =>
       Math.pow(x, 2);

   // sum :: [Num] -> Num
   const sum = xs =>
       // The numeric sum of all values in xs.
       xs.reduce((a, x) => a + x, 0);

   // MAIN ---
   return main();

})();</lang>

Output:

133
133

jq

jq supports both arrays and streams, and so we illustrate how to handle both. <lang jq># ss for an input array: def ss: map(.*.) | add;

ss for a stream, S, without creating an intermediate array:

def ss(S): reduce S as $x (0; . + ($x * $x) );</lang>We can also use a generic "SIGMA" filter that behaves like the mathematical SIGMA:<lang jq>

SIGMA(exp) computes the sum of exp over the input array:

def SIGMA(exp): map(exp) | add;

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);</lang> Finally, a "mapreduce" filter:<lang jq> def mapreduce(mapper; reducer; zero):

 if length == 0 then zero
 else map(mapper) | reducer
 end;

</lang> Demonstration:<lang jq>def demo(n):

 "ss:           \( [range(0;n)] | ss )",
 "ss(S):        \( ss( range(0;n) ) )",
 "SIGMA(.*.):   \( [range(0;n)] | SIGMA(.*.) )",
 "SIGMA(.*.;S): \( SIGMA( .*.; range(0;n) ) )",
 "mapreduce(.*.; add; 0): \( [range(0;n)] | mapreduce(.*.; add; 0) )"

demo(3) # 0^2 + 1^2 + 2^2</lang>

Output:

<lang jq>"ss: 5" "ss(S): 5" "SIGMA(.*.): 5" "SIGMA(.*.;S): 5" "mapreduce(.*.; add; 0): 5"</lang>

Julia

There are several easy ways to do this in Julia: <lang julia>julia> sum([1,2,3,4,5].^2) 55

julia> sum([x^2 for x in [1,2,3,4,5]]) 55

julia> mapreduce(x->x^2,+,[1:5]) 55

julia> sum([x^2 for x in []]) 0</lang>

K

 ss: {+/x*x}
 ss 1 2 3 4 5

55

 ss@!0

0 </lang>

Kotlin

Kotlin functional capabilities make this easy. map can be used to transform the elements of any array, collection, iterable or sequence, and then sum can be used to compute the sum. So .map {it * it}.sum().

However, when the input is a collection, map will also output a collection. This can be wasteful not only in terms of computation, but also in terms of memory. Piping a .asSequence() first will make the operation lazy, making it faster, and less memory intensive. A Kotlin Sequence is the spiritual equivalent of Java’s Stream

Still, Sequences are not free either. Kotlin also offers reduce and fold to do the above in a single operation. This is actually much faster than the above 2 approaches.

Finally, a classic for-loop can also be used. Note that because forEach and fold are inline functions, these are actually exactly as efficient as the had-written for-loop.

<lang kotlin>import kotlin.random.Random import kotlin.system.measureTimeMillis import kotlin.time.milliseconds

enum class Summer {

   MAPPING {
       override fun sum(values: DoubleArray) = values.map {it * it}.sum()
   },
   SEQUENCING {
       override fun sum(values: DoubleArray) = values.asSequence().map {it * it}.sum()
   },
   FOLDING {
       override fun sum(values: DoubleArray) = values.fold(0.0) {acc, it -> acc + it * it}
   },
   FOR_LOOP {
       override fun sum(values: DoubleArray): Double {
           var sum = 0.0
           values.forEach { sum += it * it }
           return sum
       }
   },
   ;
   abstract fun sum(values: DoubleArray): Double

}

fun main() {

   run {
       val testArrays = listOf(
           doubleArrayOf(),
           doubleArrayOf(Random.nextInt(100) / 10.0),
           DoubleArray(6) { Random.nextInt(100) / 10.0 },
       )
       for (impl in Summer.values()) {
           println("Test with ${impl.name}:")
           for (v in testArrays) println("  ${v.contentToString()} -> ${impl.sum(v)}")
       }
   }
   
   run {
       val elements = 100_000
       val longArray = DoubleArray(elements) { Random.nextDouble(10.0) }

       for (impl in Summer.values()) {
           val time = measureTimeMillis {
               impl.sum(longArray)
           }.milliseconds
           println("Summing $elements with ${impl.name} takes: $time")
       }
       var acc = 0.0
       for (v in longArray) acc += v
   }

}</lang>

Output:

Test with MAPPING:
  [] -> 0.0
  [3.5] -> 12.25
  [9.9, 9.1, 3.6, 1.2, 0.9, 2.2] -> 200.87
Test with SEQUENCING:
  [] -> 0.0
  [3.5] -> 12.25
  [9.9, 9.1, 3.6, 1.2, 0.9, 2.2] -> 200.87
Test with FOLDING:
  [] -> 0.0
  [3.5] -> 12.25
  [9.9, 9.1, 3.6, 1.2, 0.9, 2.2] -> 200.87
Test with FOR_LOOP:
  [] -> 0.0
  [3.5] -> 12.25
  [9.9, 9.1, 3.6, 1.2, 0.9, 2.2] -> 200.87
Summing 100000 elements with MAPPING takes: 31.0ms
Summing 100000 elements with SEQUENCING takes: 13.0ms
Summing 100000 elements with FOLDING takes: 2.00ms
Summing 100000 elements with FOR_LOOP takes: 2.00ms

Lambdatalk

<lang scheme> {def sumsq

{lambda {:s}
 {+ {S.map {lambda {:i} {* :i :i}} :s}}}}

-> sumsq

{sumsq 1 2 3 4 5} -> 55 {sumsq 0} -> 0 </lang>

Lang5

<lang lang5>[1 2 3 4 5] 2 ** '+ reduce .</lang>

Lasso

<lang Lasso>define sumofsquares(values::array) => {

local(sum = 0)

with value in #values do { #sum += #value * #value }

return #sum }

sumofsquares(array(1,2,3,4,5))</lang>

Output:

LFE

<lang lisp> (defun sum-sq (nums)

 (lists:foldl
   (lambda (x acc)
     (+ acc (* x x)))
   0 nums))

</lang>

Usage: <lang lisp> > (sum-sq '(3 1 4 1 5 9)) 133 </lang>

Liberty BASIC

<lang lb>' [RC] Sum of Squares

   SourceList$     ="3 1 4 1 5 9"
   'SourceList$     =""

   '   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
   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 "Sum of squares is ";         SumOfSquares

   end</lang>

LiveCode

<lang LiveCode>put "1,2,3,4,5" into nums repeat for each item n in nums

   add (n * n) to m

end repeat put m // 55</lang>

Logo

<lang logo>print apply "sum map [? * ?] [1 2 3 4 5] ; 55</lang>

Logtalk

<lang logtalk>sum(List, Sum) :-

   sum(List, 0, Sum).

sum([], Sum, Sum). sum([X| Xs], Acc, Sum) :-

   Acc2 is Acc + X,
   sum(Xs, Acc2, Sum).</lang>

Lua

<lang lua>function squaresum(a, ...) return a and a^2 + squaresum(...) or 0 end function squaresumt(t) return squaresum(unpack(t)) end

print(squaresumt{3, 5, 4, 1, 7})</lang>

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.

<lang M2000 Interpreter> Dim A() 'make an array with zero items

A=(,) 'make a pointer to array with zero items

A=(1,) 'make a pointer to array with one item

A()=A 'make a copy of array pointed by A to A()

A=A() 'make A a pointer for A()

Dim A(10)=1 'redim A() and pass 1 to each item

k=lambda m=1->{=m:m++} ' a lambda function with a closure m

Dim B(10)<<k() 'fill B() from 1 to 10

A()=B() ' copy B() to A(), A() object stay as is, but new items loaded, so pointer A points to A.

A+=100 ' add 100 to each element of A()

A(0)+=100 ' add 100 to first element

A()=Cons(A,A)

Now A and A() prints a 20 item array (Cons() add a list of arrays) Print A ' or Print A() print the same </lang>

And this is the task, using a lambda function (we can use a standard function, just use Function Square { code here })

Because M2000 modules and functions use stack for passing values, we use read statement to read a value. Functions in expressions has no return to stack because they have own stack, so passing values are filled in a fresh stack in every call. This not hold if we call function using Call (as a module), so stack is passed from parent (caller).

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)

<lang M2000 Interpreter> Module Checkit {

     A=(1,2,3,4,5)
     Square=lambda -> {
           read a
           if len(a)=0 then =0: exit
           link a to a()
           \\ make sum same type as a(0)
           sum=a(0)-a(0)
           for i=0 to len(a)-1 {sum+=a(i)*a(i)}
           =sum
     }
     Print Square(a)=55
     Print Square((,))=0 ' empty  array
     Dim k(10)=2, L()
     Print Square(K())=40
     Print Square(L())=0
     A=(1@,2@,3@,4@,5@)
     X=Square(A)
     Print Type$(X)="Decimal", X=55@

} Checkit </lang>

Maple

Mathematica/Wolfram Language

As a function 1: <lang mathematica>SumOfSquares[x_]:=Total[x^2] SumOfSquares[{1,2,3,4,5}]</lang> As a function 2: <lang mathematica>SumOfSquares[x_]:=x.x SumOfSquares[{1,2,3,4,5}]</lang> Pure function 1: (postfix operator in the following examples) <lang mathematica>{1,2,3,4,5} // Total[#^2] &</lang> Pure function 2: <lang mathematica>{1, 2, 3, 4, 5} // #^2 & // Total</lang> Pure function 3: <lang mathematica>{1, 2, 3, 4, 5} // #.#&</lang>

MATLAB

<lang Matlab>function [squaredSum] = sumofsquares(inputVector)

  squaredSum = sum( inputVector.^2 );</lang>

Maxima

<lang maxima>nums : [3,1,4,1,5,9]; sum(nums[i]^2,i,1,length(nums));</lang> or <lang maxima>nums : [3,1,4,1,5,9]; lsum(el^2, el, nums);</lang>

Mercury

<lang>

- module sum_of_squares.

- interface.

- import_module io.

- pred main(io::di, io::uo) is det.

- implementation.

- import_module int, list.

main(!IO) :-

   io.write_int(sum_of_squares([3, 1, 4, 1, 5, 9]), !IO),
   io.nl(!IO).

- func sum_of_squares(list(int)) = int.

sum_of_squares(Ns) = list.foldl((func(N, Acc) = Acc + N * N), Ns, 0). </lang>

min

Works with: min version 0.19.3

<lang min>((bool) ((dup *) (+) map-reduce) (pop 0) if) :sq-sum

(1 2 3 4 5) sq-sum puts () sq-sum puts</lang>

Output:

55
0

MiniScript

<lang MiniScript>sumOfSquares = function(seq)

   sum = 0
   for item in seq
       sum = sum + item*item
   end for
   return sum

end function

print sumOfSquares([4, 8, 15, 16, 23, 42]) print sumOfSquares([1, 2, 3, 4, 5]) print sumOfSquares([])</lang>

Output:

2854
55
0

МК-61/52

Modula-3

<lang modula3>MODULE SumSquares EXPORTS Main;

IMPORT IO, Fmt;

TYPE RealArray = ARRAY OF REAL;

PROCEDURE SumOfSquares(x: RealArray): REAL =

 VAR sum := 0.0;
 BEGIN
   FOR i := FIRST(x) TO LAST(x) DO
     sum := sum + x[i] * x[i];
   END;
   RETURN sum;
 END SumOfSquares;

BEGIN

 IO.Put(Fmt.Real(SumOfSquares(RealArray{3.0, 1.0, 4.0, 1.0, 5.0, 9.0})));
 IO.Put("\n");

END SumSquares.</lang>

MOO

<lang moo>@verb #100:sum_squares this none this rd @program #100:sum_squares sum = 0; list = args[1]; for i in (list)

 sum = sum + (i^2);

endfor player:tell(toliteral(list), " => ", sum); .

Output:

100

sum_squares({3,1,4,1,5,9})

{3, 1, 4, 1, 5, 9} => 133

100

sum_squares({})

{} => 0 </lang>

MUMPS

<lang MUMPS>SUMSQUARE(X)

;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</lang>

Nanoquery

<lang nanoquery>def sum_squares(vector)

       if len(vector) = 0
               return 0
       end

       sum = 0
       for n in vector
               sum += n ^ 2
       end
       return sum

end

println sum_squares({}) println sum_squares({1, 2, 3, 4, 5}) println sum_squares({10, 3456, 2, 6})</lang>

Output:

0
55
11944076

Nemerle

<lang Nemerle>SS(x : list[double]) : double {

   |[] => 0.0
   |_  => x.Map(fun (x) {x*x}).FoldLeft(0.0, _+_)

}</lang>

NetRexx

<lang netrexx>/*NetRexx *************************************************************

program to sum the squares of a vector of fifteen numbers.
translated from REXX
14.05.2013 Walter Pachl
- - - - /

numeric digits 50 /*allow 50-digit # (default is 9)*/ v='-100 9 8 7 6 0 3 4 5 2 1 .5 10 11 12' /* vector with some #s. */ n=v.words() x= sum=0 /*initialize SUM to zero. */

                                   /*if vector is empty, sum = zero.*/

loop Until x= /*loop until list is exhausted */

 Parse v x v                       /* pick next number              */
 If x> Then                      /* there is a number             */
   sum=sum + x**2                  /*add its square to the sum.     */
 end

say "The sum of" n "elements for the V vector is:" sum</lang>

Output:

The sum of 15 elements for the V vector is: 10650.25

NewLISP

<lang NewLISP>(apply + (map (fn(x) (* x x)) '(3 1 4 1 5 9))) -> 133 (apply + (map (fn(x) (* x x)) '())) -> 0</lang>

Nim

<lang nim>import math, sequtils

proc sumSquares[T: SomeNumber](a: openArray[T]): T =

 sum(a.mapIt(it * it))

let a1 = [1, 2, 3, 4, 5] echo a1, " → ", sumSquares(a1)

let a2: seq[float] = @[] echo a2, " → ", sumSquares(a2)</lang>

Output:

[1, 2, 3, 4, 5] → 55
@[] → 0.0

Objeck

<lang objeck> bundle Default {

 class Sum {
   function : native : SquaredSum(values : Float[]) ~ Float {
      sum := 0.0;
      for(i := 0 ; i < values->Size()	; i += 1;) {
        sum += (values[i] * values[i]);
      };
      
      return sum;
   }

   function : Main(args : String[]) ~ Nil {
      SquaredSum([3.0, 1.0, 4.0, 1.0, 5.0, 9.0])->PrintLine();
    }
 }

} </lang>

OCaml

<lang ocaml>List.fold_left (fun sum a -> sum +. a *. a) 0. floats</lang>

Octave

<lang octave>a = [1:10]; sumsq = sum(a .^ 2);</lang>

Oforth

Ol

<lang scheme> (define (sum-of-squares l)

  (fold + 0 (map * l l)))

(print (sum-of-squares '(1 2 3 4 5 6 7 8 9 10)))

==> 385

</lang>

Order

<lang c>#include <order/interpreter.h>

ORDER_PP(8to_lit(

 8seq_fold(8plus, 0,
           8seq_map(8fn(8X, 8times(8X, 8X)), 8seq(3, 1, 4, 1, 5, 9)))

))</lang>

Oz

<lang oz>declare

 fun {SumOfSquares Xs}
    for X in Xs sum:S do
       {S X*X}
    end
 end

in

 {Show {SumOfSquares [3 1 4 1 5 9]}}</lang>

PARI/GP

Generic

It is possible to apply a function, in this case ^2 to each element of an iterable and sum the result: <lang parigp>ss(v)={

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

};</lang>

Specific

For this particular task the product of a row matrix and its transpose is the sum of squares: <lang parigp> n=[2,5,23] print(n*n~) n=[] print(n*n~) </lang>

Output:

558
0

Pascal

Works with: Free_Pascal

Library: Math

Example from the documenation of the run time library: <lang pascal>Program Example45;

{ Program to demonstrate the SumOfSquares function. }

Uses math;

Var

 I : 1..100;
 ExArray : Array[1..100] of Float;

begin

 Randomize;
 for I:=low(ExArray) to high(ExArray) do
   ExArray[i]:=(Random-Random)*100;
 Writeln('Max             : ',MaxValue(ExArray):8:4);
 Writeln('Min             : ',MinValue(ExArray):8:4);
 Writeln('Sum squares     : ',SumOfSquares(ExArray):8:4);
 Writeln('Sum squares (b) : ',SumOfSquares(@ExArray[1],100):8:4);

end.</lang>

Perl

<lang perl>sub sum_of_squares {

 my $sum = 0;
 $sum += $_**2 foreach @_;
 return $sum;

}

print sum_of_squares(3, 1, 4, 1, 5, 9), "\n";</lang> or <lang perl>use List::Util qw(reduce); sub sum_of_squares {

 reduce { $a + $b **2 } 0, @_;

}

print sum_of_squares(3, 1, 4, 1, 5, 9), "\n";</lang>

Phix

function sum_of_squares(sequence s) return sum(sq_power(s,2)) end function
?apply({{},{3,1,4,1,5,9},tagset(10)},sum_of_squares)

Output:

{0,133,385}

Phixmonti

<lang Phixmonti>0 tolist 10 for 0 put endfor

0 swap len for get 2 power rot + swap endfor

drop print /# 385 #/</lang>

PHP

<lang php> function sum_squares(array $args) {

   return array_reduce(
       $args, create_function('$x, $y', 'return $x+$y*$y;'), 0
   );

} </lang>

In PHP5.3 support for anonymous functions was reworked. While the above code would still work, it is suggested to use

<lang php> function sum_squares(array $args) {

   return array_reduce($args, function($x, $y) { 
       return $x+$y*$y;
   }, 0);

} </lang> Usage for both examples: sum_squares(array(1,2,3,4,5)); // 55

Picat

 List = 1..666,
 println(sum_squares(List)),
 println(sum_squares([])),
 nl.

sum_squares([]) = 0. sum_squares(List) = sum([I*I : I in List]).</lang>

Output:

98691321
0

PicoLisp

<lang PicoLisp>: (sum '((N) (* N N)) (3 1 4 1 5 9)) -> 133

(sum '((N) (* N N)) ())

-> 0</lang>

PL/I

<lang PL/I> declare A(10) float initial (10, 9, 8, 7, 6, 5, 4, 3, 2, 1);

put (sum(A**2)); </lang>

Plain English

<lang plainenglish>To run: Start up. Create a list. Sum the squares of the list giving a ratio. Destroy the list. Write "Sum of squares: " then the ratio on the console. Wait for the escape key. Shut down.

An element is a thing with a ratio.

A list is some elements.

To add a ratio to a list: Allocate memory for an element. Put the ratio into the element's ratio. Append the element to the list.

To create a list: Add 3-1/10 to the list. Add 1/1 to the list. Add 4/1 to the list. Add 1/1 to the list. Add 5/1 to the list. Add 9/1 to the list.

To sum the squares of a list giving a ratio: Put 0 into the ratio. Get an element from the list. Loop. If the element is nil, exit. Add the element's ratio times the element's ratio to the ratio. Put the element's next into the element. Repeat.</lang>

Output:

Sum of squares: 133-61/100

Pop11

<lang pop11>define sum_squares(v);

   lvars s = 0, j;
   for j from 1 to length(v) do
       s + v(j)*v(j) -> s;
   endfor;
   s;

enddefine;

sum_squares({1 2 3 4 5}) =></lang>

PostScript

<lang> /sqrsum{ /x exch def /sum 0 def /i 0 def x length 0 eq {} { x length{ /sum sum x i get 2 exp add def /i i 1 add def }repeat }ifelse sum == }def </lang>

Library: initlib

PowerShell

<lang powershell>function Get-SquareSum ($a) {

   if ($a.Length -eq 0) {
       return 0
   } else {
       $x = $a `
            | ForEach-Object { $_ * $_ } `
            | Measure-Object -Sum
       return $x.Sum
   }

}</lang>

Prolog

   sum([],0).
   sum([H|T],S) :- sum(T, S1), S is S1 + (H * H).

PureBasic

<lang PureBasic>Procedure SumOfSquares(List base())

 ForEach base()
   Sum + base()*base()
 Next
 ProcedureReturn Sum

EndProcedure</lang>

Python

Using generator expression <lang python>sum(x * x for x in [1, 2, 3, 4, 5])

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

Functional versions: <lang python># using lambda and map: sum(map(lambda x: x * x, [1, 2, 3, 4, 5]))

or

sum(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))

or

sum(map(lambda x: pow(x, 2), [1, 2, 3, 4, 5]))

using pow and repeat

from itertools import repeat sum(map(pow, [1, 2, 3, 4, 5], repeat(2)))

using starmap and mul

from itertools import starmap from operator import mul a = [1, 2, 3, 4, 5] sum(starmap(mul, zip(a, a)))

using reduce

from functools import reduce powers_of_two = (x * x for x in [1, 2, 3, 4, 5]) reduce(lambda x, y : x + y, powers_of_two)

or

from operator import add powers_of_two = (x * x for x in [1, 2, 3, 4, 5]) reduce(add, powers_of_two)

or using a bit more complex lambda

reduce(lambda a, x: a + x*x, [1, 2, 3, 4, 5])</lang>

Using NumPy: <lang python>import numpy as np a = np.array([1, 2, 3, 4, 5]) np.sum(a ** 2)</lang>

Q

Quackery

<lang Quackery> [ 0 swap witheach [ 2 ** + ] ] is sumofsquares ( [ --> n )</lang>

Output:

Testing in the Quackery shell.

> quackery

Welcome to Quackery.

Enter "leave" to leave the shell.

/O> [ 0 swap witheach [ 2 ** + ] ] is sumofsquares
... ' [ 2 3 5 7 11 13 17 ] sumofsquares echo cr
... ' [ ] sumofsquares echo cr
... leave
... 
666
0

Sayonara.

R

Racket

lang racket

(for/sum ([x #(3 1 4 1 5 9)]) (* x x)) </lang>

Raku

(formerly Perl 6)

Works with: Rakudo version #21 "Seattle"

If this expression seems puzzling, note that * ** 2 is equivalent to {$^x ** 2}— the leftmost asterisk is not the multiplication operator but the Whatever star, which specifies currying behavior. Another convenient way to distribute the exponentiation is via the cross metaoperator, which as a list infix is looser than comma in precedence but tighter than the reduction list operator:

Raven

<lang Raven>define sumOfSqrs use $lst

  0 $lst each dup * +

[ 1 2 3 4] sumOfSqrs "Sum of squares: %d\n" print</lang>

Output:

Sum of squares: 30

Red

<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]</lang>

Output:

0
5.25

ReScript

With integers: <lang rescript>let sumOfSquares = (acc, item) => { acc + item * item }

Js.log(Js.Array2.reduce([10, 2, 4], sumOfSquares, 0))</lang>

With floats: <lang rescript>let sumOfSquares = (acc, item) => { acc +. item *. item }

Js.log(Js.Array2.reduce([10., 2., 4.], sumOfSquares, 0.))</lang>

REXX

input from pgm

<lang rexx>/*REXX program sums the squares of the numbers in a (numeric) vector of 15 numbers. */ 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.*/

=words(v) /*obtain number of words in the V list.*/

$= 0 /*initialize the sum ($) to zero. */

      do k=1  for #                             /*process each number in the V vector. */
      $=$ + word(v,k)**2                        /*add a squared element to the ($) sum.*/
      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: " $</lang> output using an internal vector (list) of numbers:

The sum of  15  squared elements for the  V  vector is:  10650.25

input from C.L.

<lang rexx>/*REXX program sums the squares of the numbers in a (numeric) vector of 15 numbers. */ numeric digits 100 /*allow 100─digit numbers; default is 9*/ parse arg v /*get optional numbers from the C.L. */ if v= then v= -100 9 8 7 6 0 3 4 5 2 1 .5 10 11 12 /*Not specified? Use default*/

=words(v) /*obtain number of words in V*/

say 'The vector of ' # " elements is: " space(v) /*display the vector numbers.*/ $= 0 /*initialize the sum ($) to zero. */

            do  until v==;   parse var v x v  /*process each number in the V vector. */
            $=$ + x**2                          /*add a squared element to the ($) sum.*/
            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: " $</lang> output using a vector (list) of numbers from the command line:

The vector of  10  elements is:  -1000 -100 -10 -1 0 +1 +10 100 1000 1e20

The sum of  10  squared elements for the  V  vector is:  10000000000000000000000000000000002020202

Ring

<lang ring> aList = [1,2,3,4,5] see sumOfSquares(aList)

func sumOfSquares sos sumOfSquares = 0 for i=1 to len(sos)

   sumOfSquares = sumOfSquares + pow(sos[i],2)

next return sumOfSquares </lang>

Ruby

<lang ruby>[3,1,4,1,5,9].reduce(0){|sum,x| sum + x*x}</lang>

or with the Ruby 2.4+ method sum.

Run BASIC

<lang runbasic>list$ = "1,2,3,4,5" print sumOfSquares(list$)

FUNCTION sumOfSquares(sos$)

 while word$(sos$,i+1,",") <> ""
   i = i + 1
   sumOfSquares = sumOfSquares + val(word$(sos$,i,","))^2
 wend

END FUNCTION</lang>

Rust

<lang rust>fn sq_sum(v: &[f64]) -> f64 {

   v.iter().fold(0., |sum, &num| sum + num*num)

}

fn main() {

   let v = vec![3.0, 1.0, 4.0, 1.0, 5.5, 9.7];
   println!("{}", sq_sum(&v));

   let u : Vec<f64> = vec![];
   println!("{}", sq_sum(&u));

}</lang>

Sather

<lang sather>class MAIN is

 sqsum(s, e:FLT):FLT is
   return s + e*e;
 end;

 sum_of_squares(v :ARRAY{FLT}):FLT is
   return (#ARRAY{FLT}(|0.0|).append(v)).reduce(bind(sqsum(_,_)));
 end;

 main is
   v :ARRAY{FLT} := |3.0, 1.0, 4.0, 1.0, 5.0, 9.0|;
   #OUT + sum_of_squares(v) + "\n";
 end;

end;</lang>

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.

<lang scala>def sum_of_squares(xs: Seq[Double]) = xs.foldLeft(0) {(a,x) => a + x*x}</lang>

Scheme

<lang scheme>(define (sum-of-squares l)

 (apply + (map * l l)))</lang>

> (sum-of-squares (list 3 1 4 1 5 9))
133

Seed7

<lang seed7>$ include "seed7_05.s7i";

 include "float.s7i";

const array float: list1 is [] (3.0, 1.0, 4.0, 1.0, 5.0, 9.0); const array float: list2 is 0 times 0.0;

const func float: squaredSum (in array float: floatList) is func

 result
   var float: sum is 0.0;
 local
   var float: number is 0.0;
 begin
   for number range floatList do
     sum +:= number ** 2;
   end for;
 end func;

const proc: main is func

 begin
   writeln(squaredSum(list1));
   writeln(squaredSum(list2));
 end func;</lang>

Sidef

<lang ruby>func sum_of_squares(vector) {

   var sum = 0;
   vector.each { |n| sum += n**2 };
   return sum;

}

say sum_of_squares([]); # 0 say sum_of_squares([1,2,3]); # 14</lang>

Slate

<lang slate>{1. 2. 3} reduce: [|:x :y| y squared + x]. {} reduce: [|:x :y| y squared + x] ifEmpty: [0].</lang>

Smalltalk

<lang smalltalk>#(3 1 4 1 5 9) inject: 0 into: [:sum :aNumber | sum + aNumber squared]</lang>

SNOBOL4

Works with: Macro Spitbol

Works with: Snobol4+

Works with: CSnobol

<lang SNOBOL4> define('ssq(a)i') :(ssq_end) ssq i = i + 1; ssq = ssq + (a * a) :s(sumsq)f(return) ssq_end

# Fill array, test and display
str = '1 2 3 5 7 11 13 17 19 23'; a = array(10)
loop i = i + 1; str len(p) span('0123456789') . a @p :s(loop)
output = str ' -> ' sumsq(a)
end</lang>

Output:
1 2 3 5 7 11 13 17 19 23 -> 1557
SQL
<lang sql>select sum(x*x) from vector</lang>
Note that this assumes that the values in our vector are named x.
Standard ML
<lang sml>foldl (fn (a, sum) => sum + a * a) 0 ints</lang>
<lang sml>foldl (fn (a, sum) => sum + a * a) 0.0 reals</lang>
Stata
Mata
<lang stata>a = 1..100 sum(a:^2)
338350
a = J(0, 1, .) length(a)
0
sum(a:^2)
0</lang>
Swift
<lang swift>func sumSq(s: [Int]) -> Int {
return s.map{$0 * $0}.reduce(0, +)
}</lang>
Tailspin
<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 </lang>
Tcl
<lang tcl>package require Tcl 8.6 namespace path ::tcl::mathop
{*} is like apply in Scheme--it turns a list into multiple arguments
proc sum_of_squares lst {
+ {*}[lmap x $lst {* $x $x}]
} puts [sum_of_squares {1 2 3 4}]; # ==> 30 puts [sum_of_squares {}]; # ==> 0 </lang>
Trith
<lang trith>[3 1 4 1 5 9] 0 [dup * +] foldl</lang>
TUSCRIPT
<lang tuscript> $$ MODE TUSCRIPT array="3'1'4'1'5'9",sum=0 LOOP a=array sum=sum+(a*a) ENDLOOP PRINT sum </lang>

Output:
133
UnixPipes
<lang bash>folder() {
(read B; res=$( expr $1 \* $1 ) ; test -n "$B" && expr $res + $B || echo $res)
}
fold() {
(while read a ; do fold | folder $a done)
}

(echo 3; echo 1; echo 4;echo 1;echo 5; echo 9) | fold</lang>
Unix shell
<lang Unixshell>$ cat toto 1 2 4 8 16 $ cat toto toto | paste -sd* 1*2*4*8*16*1*2*4*8*16 $ cat toto toto | paste -sd* | bc -l 1048576 </lang>
Ursala
The ssq function defined below zips two copies of its argument together, maps the product function to all pairs, and then sums the result by way of the reduction operator, -:. <lang Ursala>#import nat
ssq = sum:-0+ product*iip
cast %n
main = ssq <21,12,77,0,94,23,96,93,72,72,79,24,8,50,9,93></lang>

Output:
62223
V
<lang v>[sumsq [dup *] map 0 [+] fold].
[] sumsq =0 [1 2 3] sumsq</lang>
=14
VBA
<lang vb>Public Sub sum_of_squares()
Debug.Print WorksheetFunction.SumSq([{1,2,3,4,5,6,7,8,9,10}])

End Sub</lang>

Output:
385
VBScript
<lang vb> Function sum_of_squares(arr) If UBound(arr) = -1 Then sum_of_squares = 0 End If For i = 0 To UBound(arr) sum_of_squares = sum_of_squares + (arr(i)^2) Next End Function
WScript.StdOut.WriteLine sum_of_squares(Array(1,2,3,4,5)) WScript.StdOut.WriteLine sum_of_squares(Array()) </lang>

Output:
55 0
Visual Basic .NET
<lang vbnet>
Private Shared Function sumsq(ByVal i As ICollection(Of Integer)) As Integer If i Is Nothing OrElse i.Count = 0 Then Return 0 End If Return i.[Select](Function(x) x * x).Sum() End Function
Private Shared Sub Main() Dim a As Integer() = New Integer() {1, 2, 3, 4, 5} ' 55 Console.WriteLine(sumsq(a)) For K As Integer = 0 To 16 Console.WriteLine("SumOfSquares({0}) = {1}", K, SumOfSquares(K)) Next End Sub Function SumOfSquares(ByVal Max As Integer) Dim Square As Integer = 0 Dim Add As Integer = 1 Dim Sum As Integer = 0 For J As Integer = 0 To Max - 1 Square += Add Add += 2 Sum += Square Next Return Sum End Function
Function SumOfSquaresByMult(ByVal Max As Integer) Dim Sum As Integer = 0 For J As Integer = 1 To Max Sum += J * J Next Return Sum End Function
</lang>

Output:
55 SumOfSquares(0) = 0 SumOfSquares(1) = 1 SumOfSquares(2) = 5 SumOfSquares(3) = 14 SumOfSquares(4) = 30 SumOfSquares(5) = 55 SumOfSquares(6) = 91 SumOfSquares(7) = 140 SumOfSquares(8) = 204 SumOfSquares(9) = 285 SumOfSquares(10) = 385 SumOfSquares(11) = 506 SumOfSquares(12) = 650 SumOfSquares(13) = 819 SumOfSquares(14) = 1015 SumOfSquares(15) = 1240 SumOfSquares(16) = 1496
Wortel
<lang wortel>@sum !*^@sq [3 1 4 1 5 9] ; returns 133</lang> <lang wortel>@sum !*^@sq [] ; returns 0</lang> As a function: <lang wortel>^(@sum *^@sq)</lang> Iterative function: <lang wortel>&a [@var sum 0 @for x of a :!+sum *x x sum]</lang>
Wren
<lang ecmascript>var sumSquares = Fn.new { |v| v.reduce(0) { |sum, n| sum + n * n } }
var v = [1, 2, 3, -1, -2, -3] System.print("Vector : %(v)") System.print("Sum of squares : %(sumSquares.call(v))")</lang>

Output:
Vector : [1, 2, 3, -1, -2, -3] Sum of squares : 28
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 SUMSQ and use that instead of SUM-OF-SQUARES. <lang lisp>(defun sum-of-squares (vec)
(defun sumsq (xs) (if (null xs) 0 (+ (expt (car xs) 2) (sumsq (cdr xs))))) (sumsq (vector->list vec)))
(define first-seven-primes #(2 3 5 7 11 13 17))
(define zero-length-vector #())
(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)))</lang>

Output:
(THE SUM OF THE SQUARES OF THE FIRST SEVEN PRIME NUMBERS IS 666) (THE SUM OF THE SQUARES OF NO NUMBERS AT ALL IS 0)
XPL0
<lang XPL0>include c:\cxpl\codes; \intrinsic 'code' declarations
func SumSq(V, L); int V, L; int S, I; [S:= 0; for I:= 0 to L-1 do S:= S+sq(V(I)); return S; ]; \SumSq
[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
]</lang>

Output:
385 0
zkl
<lang zkl>T().reduce(fcn(p,n){ p + n*n },0) //-->0 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</lang>