Sum of squares: Difference between revisions

 

=={{header|0815}}==

{x{*%<:d:~$<:1:~>><:2:~>><:3:~>><:4:~>><:5:~>><:6:~>><:7:

~>><:8:~>><:9:~>><:a:~>><:b:~>><:c:~>><:ffffffffffffffff:

~>{x{*>}:8f:{x{*&{=+>{~>&=x<:ffffffffffffffff:/#:8f:{{~%

{{out}}

<pre>

0

28A

</pre>

 

=={{header|360 Assembly}}==

SUMOFSQR CSECT

USING SUMOFSQR,R12

N DC AL2((PG-A)/4)

YREGS

{{out}}

<pre>

=={{header|8086 Assembly}}==

 

cpu 8086

bits 16

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

 

=={{header|ACL2}}==

(if (endp xs)

0

(+ (* (first xs) (first xs))

 

=={{header|ActionScript}}==

{

var sum:Number = 0;

sum += vector[i]*vector[i];

return sum;

 

=={{header|Ada}}==

 

procedure Test_Sum_Of_Squares is

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

{{out}}

<pre>

 

=={{header|Aime}}==

squaredsum(list l)

{

 

0;

{{out}}

<pre>14

0

4.5</pre>

 

=={{header|ALGOL 68}}==

 

The computation can be written as a loop.

REAL sum := 0;

FOR i FROM LWB argv TO UPB argv DO

test:(

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

{{out}}

<pre>

 

{{trans|python}}

 

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

sum := 0;

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

{{out}}

<pre>

{{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 -*- #

 

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>

 

=={{header|ALGOL W}}==

real procedure sumSquares ( real array vector ( * )

; integer value lb

r_format := "A"; r_w := 10; r_d := 1; % set fixed point output %

write( sumSquares( numbers, 1, 5 ) );

 

=={{header|Alore}}==

 

var sum = 0

for i in a

 

WriteLn(sum_squares([3,1,4,1,5,9]))

 

=={{header|APL}}==

square_sum 1 2 3 4 5

55

square_sum ⍬ ⍝The empty vector

 

=={{header|AppleScript}}==

 

Two ways of composing a sumOfSquares function:

 

-- sumOfSquares :: Num a => [a] -> a

foldl(add, 0, xs)

{{Out}}

 

=={{header|Arturo}}==

 

 

{{out}}

 

=={{header|Astro}}==

 

=={{header|AutoHotkey}}==

Loop, Parse, list, %A_Space%

sum += A_LoopField**2

 

=={{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

 

 

=={{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

 

==={{header|BaCon}}===

FUNCTION ss(int arr[], NUMBER elem)

sum = 0

vector[i] = i + 1

NEXT

 

{{out}}

prompt$ ./sumsquares -s 1000

333833500</pre>

 

==={{header|BBC BASIC}}===

BBC BASIC cannot have a zero-length array.

vector() = 1, 2, 3, 4, 5, 6

{{out}}

<pre>Sum of squares = 91</pre>

 

==={{header|IS-BASIC}}===

110 NUMERIC A(1 TO N)

120 FOR I=1 TO N

200 NEXT

210 LET SQ=S

 

=={{header|bc}}==

auto i, s

return(s)

 

=={{header|Bracmat}}==

= sum component

. 0:?sum

& out$(sumOfSquares$(3 4 i*5))

& out$(sumOfSquares$(a b c))

{{out}}

<pre>25

 

=={{header|Brat}}==

 

=={{header|C}}==

 

 

double squaredsum(double *l, int e)

printf("%lf\n", squaredsum(NULL, 0));

return 0;

 

=={{header|C sharp|C#}}==

 

using System.Collections.Generic;

using System.Linq;

Console.WriteLine(SumOfSquares(new int[] { })); // 0

}

 

=={{header|C++}}==

===Using accumulate===

#include <numeric>

#include <vector>

std::cout << vec_add_squares(v) << std::endl;

return 0;

===Using inner_product===

#include <numeric>

#include <vector>

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"

 

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.

Serves 1.

 

 

=={{header|Clojure}}==

 

=={{header|CoffeeScript}}==

sumOfSquares = ( list ) ->

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

 

=={{header|Common Lisp}}==

 

 

=={{header|Cowgol}}==

 

include "argv.coh";

 

# Print sum of squares of numbers

print_i32(sumsquare(&nums[0], len as intptr));

 

{{out}}

=={{header|Crystal}}==

 

def sum_squares(a)

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

puts sum_squares([1, 2, 3])

# => 14

 

=={{header|D}}==

===Iterative Version===

T sum = 0;

foreach (e; a)

 

[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 {

items.sumSquares.writeln;

10.iota.sumSquares.writeln;

{{out}}

<pre>133.61

=={{header|Dart}}==

===Iterative Version===

var sum=0;

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

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

print(sumOfSquares([10]));

{{out}}

<pre>0

 

===Functional Style Version===

.fold(0, (num p,num n)=> p + n);

 

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

print(sumOfSquares([10]));

{{out}}

<pre>0

=={{header|Delphi}}==

Delphi has standard SumOfSquares function in Math unit:

 

{$APPTYPE CONSOLE}

Writeln(SumOfSquares(A):6:2); // 30.00

Readln;

 

=={{header|E}}==

 

var sum := 0

for x in numbers {

}

return sum

 

=={{header|Eiffel}}==

 

class

APPLICATION

 

end

 

=={{header|Elena}}==

import extensions;

SumOfSquares(list)

public program()

.printLine(SumOfSquares(new int[]{1, 2, 3, 4, 5}))

.printLine(SumOfSquares(Array.MinValue))

{{out}}

<pre>

 

=={{header|Elixir}}==

 

=={{header|Emacs Lisp}}==

 

 

=={{header|Erlang}}==

 

=={{header|Euphoria}}==

atom sum

sum = 0

end for

return sum

 

=={{header|Excel}}==

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

 

=SUMSQ(A1:A10)

 

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

 

12 3 5 23 13 67 15 9 4 2

5691

 

=={{header|F_Sharp|F#}}==

 

=={{header|Factor}}==

 

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

 

 

=={{header|FALSE}}==

0 3 1 4 1 5 9$*\ [$0=~][$*+\]#%.

 

=={{header|Fantom}}==

class SumSquares

{

}

}

 

=={{header|Fish}}==

\0&

>l?!v:*&+&

 

=={{header|Forth}}==

0e

dup 0= if 2drop exit then

 

create test 3e f, 1e f, 4e f, 1e f, 5e f, 9e f,

 

=={{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

result = sum(a**2) ! Use exponentiation operator to get squares

 

 

=={{header|FreeBASIC}}==

 

Function SumSquares(a() As Double) As Double

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|Frink}}==

f = {|x| x^2} // Anonymous function which squares its argument

a = [1,2,3,5,7]

println[sum[map[f,a], 0]]

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|GAP}}==

# It's necessary to check for the empty vector though

SumSq := function(v)

return v*v;

fi;

 

=={{header|GEORGE}}==

0

1, n rep (i)

read print dup mult +

]

data

<pre>

=={{header|Go}}==

;Implementation

 

import "fmt"

}

fmt.Println(sum)

{{out}}

<pre>

</pre>

;Library

 

import (

func main() {

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

{{out}}

<pre>

 

=={{header|Golfscript}}==

# usage example

 

=={{header|Groovy}}==

 

// square via multiplication

sumSq = array.collect { it ** 2 }.sum()

 

 

{{out}}

=={{header|Haskell}}==

Three approaches:

versions =

[ sum . fmap (^ 2) -- ver 1

main :: IO ()

main =

{{Out}}

<pre>[133,91,0,1]

 

=={{header|Icon}} and {{header|Unicon}}==

local lst

lst := []

every total +:= !lst ^ 2

return total

 

=={{header|IDL}}==

 

 

=={{header|Inform 7}}==

 

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

say line break;

say the sum of squares of {1, 2, 3};

 

=={{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

x=: 20 4 ?@$ 0 NB. a 20-by-4 table of random (0,1) numbers

ss x

 

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.

0

ss1 x

 

=={{header|Java}}==

{{works with|Java|1.5+}}

{

public static void main(final String[] args)

System.out.println("The sum of the squares is: " + sum);

}

 

=={{header|JavaScript}}==

===ES5===

var sum = 0;

var i, iLen;

}

 

 

An alternative using a while loop and Math.pow

 

var sum = 0,

i = array.length;

}

 

 

 

 

map (JS 1.6) and reduce (JS 1.8)

 

 

===ES6===

 

Two ways of composing a sumOfSquares function

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>133

133</pre>

 

=={{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:

# 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 mapreduce(mapper; reducer; zero):

if length == 0 then zero

else map(mapper) | reducer

end;

"ss: \( [range(0;n)] | ss )",

"ss(S): \( ss( range(0;n) ) )",

;

 

{{out}}

"ss(S): 5"

"SIGMA(.*.): 5"

"SIGMA(.*.;S): 5"

 

=={{header|Julia}}==

There are several easy ways to do this in Julia:

55

 

 

julia> sum([x^2 for x in []])

 

=={{header|K}}==

ss: {+/x*x}

ss 1 2 3 4 5

ss@!0

0

 

=={{header|Kotlin}}==

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

for (v in longArray) acc += v

}

 

{{out}}

 

=={{header|Lambdatalk}}==

{def sumsq

{lambda {:s}

{sumsq 0}

-> 0

 

=={{header|Lang5}}==

 

=={{header|Lasso}}==

 

local(sum = 0)

}

 

{{out}}

<pre>55</pre>

 

=={{header|LFE}}==

(defun sum-sq (nums)

(lists:foldl

(+ acc (* x x)))

0 nums))

 

Usage:

> (sum-sq '(3 1 4 1 5 9))

133

 

=={{header|Liberty BASIC}}==

 

SourceList$ ="3 1 4 1 5 9"

print "Sum of squares is "; SumOfSquares

 

 

=={{header|LiveCode}}==

repeat for each item n in nums

add (n * n) to m

end repeat

 

=={{header|Logo}}==

 

=={{header|Logtalk}}==

sum(List, 0, Sum).

 

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

Acc2 is Acc + X,

 

=={{header|Lua}}==

function squaresumt(t) return squaresum(unpack(t)) end

 

 

=={{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.

 

Dim A() 'make an array with zero items

 

Now A and A() prints a 20 item array (Cons() add a list of arrays)

Print A ' or Print A() print the same

 

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

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)

 

Module Checkit {

A=(1,2,3,4,5)

}

Checkit

 

=={{header|Maple}}==

F := V -> add(v^2, v in V):

F(<1,2,3,4,5>);

 

As a function 1:

As a function 2:

Pure function 1: (postfix operator in the following examples)

Pure function 2:

Pure function 3:

 

=={{header|MATLAB}}==

 

=={{header|Maxima}}==

or

 

=={{header|Mercury}}==

:- module sum_of_squares.

:- interface.

 

sum_of_squares(Ns) = list.foldl((func(N, Acc) = Acc + N * N), Ns, 0).

 

=={{header|min}}==

{{works with|min|0.19.3}}

 

(1 2 3 4 5) sq-sum puts

{{out}}

<pre>

 

=={{header|MiniScript}}==

sum = 0

for item in seq

print sumOfSquares([4, 8, 15, 16, 23, 42])

print sumOfSquares([1, 2, 3, 4, 5])

{{out}}

<pre>2854

 

=={{header|МК-61/52}}==

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt;

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

IO.Put("\n");

 

=={{header|MOO}}==

@program #100:sum_squares

sum = 0;

;#100:sum_squares({})

{} => 0

 

=={{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

 

=={{header|Nanoquery}}==

if len(vector) = 0

return 0

println sum_squares({})

println sum_squares({1, 2, 3, 4, 5})

{{out}}

<pre>0

 

=={{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

sum=sum + x**2 /*add its square to the sum. */

end

{{out}}

<pre>The sum of 15 elements for the V vector is: 10650.25</pre>

 

=={{header|NewLISP}}==

-> 133

(apply + (map (fn(x) (* x x)) '()))

 

=={{header|Nim}}==

 

 

=={{header|Objeck}}==

bundle Default {

class Sum {

}

}

 

=={{header|OCaml}}==

 

 

 

=={{header|Octave}}==

 

 

=={{header|Oforth}}==

 

 

=={{header|Ol}}==

(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

 

=={{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

end

in

 

=={{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~)

{{out}}

<pre>

{{libheader|Math}}

Example from the documenation of the run time library:

 

{ Program to demonstrate the SumOfSquares function. }

Writeln('Sum squares : ',SumOfSquares(ExArray):8:4);

Writeln('Sum squares (b) : ',SumOfSquares(@ExArray[1],100):8:4);

 

=={{header|Perl}}==

my $sum = 0;

$sum += $_**2 foreach @_;

}

 

or

sub sum_of_squares {

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

}

 

 

=={{header|Phix}}==

 

=={{header|Phixmonti}}==

10 for 0 put endfor

 

endfor

 

 

=={{header|PHP}}==

function sum_squares(array $args) {

return array_reduce(

);

}

 

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

}, 0);

}

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

 

=={{header|PicoLisp}}==

-> 133

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

 

=={{header|PL/I}}==

declare A(10) float initial (10, 9, 8, 7, 6, 5, 4, 3, 2, 1);

 

put (sum(A**2));

 

=={{header|Plain English}}==

Start up.

Create a list.

Add the element's ratio times the element's ratio to the ratio.

Put the element's next into the element.

{{out}}

<pre>

=={{header|Pop11}}==

 

lvars s = 0, j;

for j from 1 to length(v) do

enddefine;

 

 

=={{header|PostScript}}==

/sqrsum{

/x exch def

sum ==

}def

 

{{libheader|initlib}}

[3 1 4 1 5 9] 0 {dup * +} fold

 

=={{header|PowerShell}}==

if ($a.Length -eq 0) {

return 0

return $x.Sum

}

 

=={{header|Prolog}}==

 

=={{header|PureBasic}}==

ForEach base()

Sum + base()*base()

Next

ProcedureReturn Sum

 

=={{header|Python}}==

'''Using generator expression'''

# or

sum(x ** 2 for x in [1, 2, 3, 4, 5])

# or

 

'''Functional versions:'''

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

# or

reduce(add, powers_of_two)

# or using a bit more complex lambda

 

'''Using NumPy:'''

a = np.array([1, 2, 3, 4, 5])

 

=={{header|Q}}==

 

=={{header|Quackery}}==

 

 

{{out}}

 

=={{header|R}}==

 

=={{header|Racket}}==

#lang racket

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

 

=={{header|Raku}}==

(formerly Perl 6)

 

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.

as a list infix is looser than comma in precedence but tighter than the reduction list operator:

 

 

=={{header|Raven}}==

0 $lst each dup * +

 

{{out}}

<pre>Sum of squares: 30</pre>

 

=={{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.*/

end /*k*/ /* [↑] if vector is empty, then sum=0.*/

/*stick a fork in it, we're all done. */

'''output''' &nbsp; using an internal vector (list) of numbers:

<pre>

 

===input from C.L.===

numeric digits 100 /*allow 100─digit numbers; default is 9*/

parse arg v /*get optional numbers from the C.L. */

end /*until*/ /* [↑] if vector is empty, then sum=0.*/

say /*stick a fork in it, we're all done. */

'''output''' &nbsp; using a vector (list) of numbers from the command line:

<pre>

 

=={{header|Ring}}==

aList = [1,2,3,4,5]

see sumOfSquares(aList)

next

return sumOfSquares

 

 

 

 

=={{header|Run BASIC}}==

print sumOfSquares(list$)

 

sumOfSquares = sumOfSquares + val(word$(sos$,i,","))^2

wend

 

=={{header|Rust}}==

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

}

let u : Vec<f64> = vec![];

println!("{}", sq_sum(&u));

 

=={{header|Sather}}==

 

sqsum(s, e:FLT):FLT is

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

 

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

 

=={{header|Seed7}}==

include "float.s7i";

writeln(squaredSum(list1));

writeln(squaredSum(list2));

 

=={{header|Sidef}}==

var sum = 0;

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

 

say sum_of_squares([]); # 0

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

 

=={{header|SNOBOL4}}==

{{works with|CSnobol}}

 

ssq i = i + 1; ssq = ssq + (a<i> * a<i>) :s(sumsq)f(return)

ssq_end

loop i = i + 1; str len(p) span('0123456789') . a<i> @p :s(loop)

output = str ' -> ' sumsq(a)

 

{{out}}

=={{header|SQL}}==

 

 

Note that this assumes that the values in our vector are named <code>x</code>.

=={{header|Standard ML}}==

 

 

 

=={{header|Stata}}==

=== Mata ===

sum(a:^2)

338350

0

sum(a:^2)

 

=={{header|Swift}}==

 

return s.map{$0 * $0}.reduce(0, +)

 

 

 

namespace path ::tcl::mathop

 

}

 

=={{header|Trith}}==

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

array="3'1'4'1'5'9",sum=0

ENDLOOP

PRINT sum

{{out}}

<pre>

=={{header|UnixPipes}}==

 

(read B; res=$( expr $1 \* $1 ) ; test -n "$B" && expr $res + $B || echo $res)

}

 

 

 

{{out}}

 

=={{header|Ursala}}==

maps the product function to all pairs, and then sums the

result by way of the reduction operator, -:.

 

ssq = sum:-0+ product*iip

#cast %n

 

{{out}}

<pre>62223</pre>

 

=={{header|V}}==

 

[] sumsq

=0

=14

 

=={{header|VBA}}==

Debug.Print WorksheetFunction.SumSq([{1,2,3,4,5,6,7,8,9,10}])

<pre> 385 </pre>

 

=={{header|VBScript}}==

Function sum_of_squares(arr)

If UBound(arr) = -1 Then

WScript.StdOut.WriteLine sum_of_squares(Array(1,2,3,4,5))

WScript.StdOut.WriteLine sum_of_squares(Array())

 

{{Out}}

 

=={{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

End Function

{{out}}

<pre>

SumOfSquares(15) = 1240

SumOfSquares(16) = 1496

</pre>

 

=={{header|Wortel}}==

As a function:

Iterative function:

 

=={{header|Wren}}==

 

var v = [1, 2, 3, -1, -2, -3]

System.print("Vector : %(v)")

 

{{out}}

=={{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)

(print `(the sum of the squares of the first seven prime numbers is ,(sum-of-squares first-seven-primes)))

 

{{out}}

<pre>(THE SUM OF THE SQUARES OF THE FIRST SEVEN PRIME NUMBERS IS 666)

 

=={{header|XPL0}}==

 

func SumSq(V, L);

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

 

=={{header|zkl}}==

T(3,1,4,1,5,9).reduce(fcn(p,n){ p + n*n },0.0) //-->133.0