I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Sum of elements below main diagonal of matrix

Sum of elements below main diagonal of matrix
You are encouraged to solve this task according to the task description, using any language you may know.

Find and display the sum of elements that are below the main diagonal of a matrix.

The matrix should be a square matrix.

───   Matrix to be used:   ───

```     [[1,3,7,8,10],
[2,4,16,14,4],
[3,1,9,18,11],
[12,14,17,18,20],
[7,1,3,9,5]]
```

## 11l

Translation of: Nim
`F sumBelowDiagonal(m)   V result = 0   L(i) 1 .< m.len      L(j) 0 .< i         result += m[i][j]   R result V m = [[ 1,  3,  7,  8, 10],       [ 2,  4, 16, 14,  4],       [ 3,  1,  9, 18, 11],       [12, 14, 17, 18, 20],       [ 7,  1,  3,  9,  5]] print(sumBelowDiagonal(m))`
Output:
```69
```

## Action!

`PROC PrintMatrix(INT ARRAY m BYTE size)  BYTE x,y  INT v   FOR y=0 TO size-1  DO    FOR x=0 TO size-1    DO      v=m(x+y*size)      IF v<10 THEN Put(32) FI      PrintB(v) Put(32)    OD    PutE()  ODRETURN INT FUNC SumBelowDiagonal(INT ARRAY m BYTE size)  BYTE x,y  INT sum   sum=0  FOR y=1 TO size-1  DO    FOR x=0 TO y-1    DO      sum==+m(x+y*size)    OD  ODRETURN (sum) PROC Main()  INT sum  INT ARRAY m=[     1  3  7  8 10     2  4 16 14  4     3  1  9 18 11    12 14 17 18 20     7  1  3  9  5]   PrintE("Matrix")  PrintMatrix(m,5)  PutE()  sum=SumBelowDiagonal(m,5)  PrintF("Sum below diagonal is %I",sum)RETURN`
Output:
```Matrix
1  3  7  8 10
2  4 16 14  4
3  1  9 18 11
12 14 17 18 20
7  1  3  9  5

Sum below diagonal is 69
```

`with Ada.Text_Io;with Ada.Numerics.Generic_Real_Arrays; procedure Sum_Below_Diagonals is    type Real is new Float;    package Real_Arrays   is new Ada.Numerics.Generic_Real_Arrays (Real);    function Sum_Below_Diagonal (M : Real_Arrays.Real_Matrix) return Real   with Pre => M'Length (1) = M'Length (2)   is      Sum : Real := 0.0;   begin      for Row in 0 .. M'Length (1) - 1 loop         for Col in 0 .. Row - 1 loop            Sum := Sum + M (M'First (1) + Row,                            M'First (2) + Col);         end loop;      end loop;      return Sum;   end Sum_Below_Diagonal;    M : constant Real_Arrays.Real_Matrix :=     (( 1.0,  3.0,  7.0,  8.0, 10.0),      ( 2.0,  4.0, 16.0, 14.0,  4.0),      ( 3.0,  1.0,  9.0, 18.0, 11.0),      (12.0, 14.0, 17.0, 18.0, 20.0),      ( 7.0,  1.0,  3.0,  9.0,  5.0));   Sum : constant Real := Sum_Below_Diagonal (M);    package Real_Io is new Ada.Text_Io.Float_Io (Real);   use Ada.Text_Io, Real_Io;begin   Put ("Sum below diagonal: ");   Put (Sum, Exp => 0, Aft => 1);   New_Line;end Sum_Below_Diagonals;`
Output:
`Sum below diagonal: 69.0`

## ALGOL 68

`BEGIN # sum the elements below the main diagonal of a matrix  #    # returns the sum of the elements below the main diagonal #    # of m, m must be a square matrix                         #    OP   LOWERSUM = ( [,]INT m )INT:         IF 1 LWB m /= 2 LWB m OR 1 UPB m /= 2 UPB m THEN            # the matrix isn't square                         #            print( ( "Matrix must be suare for LOWERSUM", newline ) );            stop         ELSE            # have a square matrix                            #            INT sum := 0;            FOR r FROM 1 LWB m + 1 TO 1 UPB m DO                 FOR c FROM 1 LWB m TO r - 1 DO                     sum +:= m[ r, c ]                 OD            OD;            sum         FI; # LOWERSUM #    # task test case                                          #    print( ( whole( LOWERSUM [,]INT( (  1,  3,  7,  8, 10 )                                   , (  2,  4, 16, 14,  4 )                                   , (  3,  1,  9, 18, 11 )                                   , ( 12, 14, 17, 18, 20 )                                   , (  7,  1,  3,  9,  5 )                                   )                  , 0                  )            , newline            )          )END`
Output:
```69
```

## ALGOL W

One of the rare occasions where the lack of lower/upper bound operators in Algol W actually simplifies things, assuming the programmer gets things right...

`begin % sum the elements below the main diagonal of a matrix  %    % returns the sum of the elements below the main diagonal %    % of m, m must have bounds lb :: ub, lb :: ub             %    integer procedure lowerSum ( integer array m ( *, * )                               ; integer value lb, ub                               ) ;    begin        integer sum;        sum := 0;        for r := lb + 1 until ub do begin             for c := lb until r - 1 do sum := sum + m( r, c )        end for_r;        sum    end lowerSum ;    begin % task test case                                    %        integer array m ( 1 :: 5, 1 :: 5 );        integer r, c;        r := 1; c := 0; for v :=  1,  3,  7,  8, 10 do begin c := c + 1; m( r, c ) := v end;        r := 2; c := 0; for v :=  2,  4, 16, 14,  4 do begin c := c + 1; m( r, c ) := v end;        r := 3; c := 0; for v :=  3,  1,  9, 18, 11 do begin c := c + 1; m( r, c ) := v end;        r := 4; c := 0; for v := 12, 14, 17, 18, 20 do begin c := c + 1; m( r, c ) := v end;        r := 5; c := 0; for v :=  7,  1,  3,  9,  5 do begin c := c + 1; m( r, c ) := v end;        write( i_w := 1, lowerSum( m, 1, 5 ) )    endend.`
Output:
```69
```

## APL

Works with: Dyalog APL
`sum_below_diagonal ← +/(∊⊢×(>/¨⍳∘⍴))`
Output:
```      matrix ← 5 5⍴1 3 7 8 10 2 4 16 14 4 3 1 9 18 11 12 14 17 18 20 7 1 3 9 5
sum_below_diagonal matrix
69```

## AutoHotkey

`matrx :=[[1,3,7,8,10]		,[2,4,16,14,4]		,[3,1,9,18,11]		,[12,14,17,18,20]		,[7,1,3,9,5]]sumA := sumB := sumD :=  sumAll := 0for r, obj in matrx	for c, val in obj		sumAll += val		,sumA += r<c ? val : 0		,sumB += r>c ? val : 0		,sumD += r=c ? val : 0 MsgBox % result := "sum above diagonal = " sumA . "`nsum below diagonal = " sumB . "`nsum on diagonal = " sumD . "`nsum all = " sumAll`
Output:
```sum above diagonal = 111
sum below diagonal = 69
sum on diagonal = 37
sum all = 217```

## AWK

` # syntax: GAWK -f SUM_OF_ELEMENTS_BELOW_MAIN_DIAGONAL_OF_MATRIX.AWKBEGIN {    arr1[++n] = "1,3,7,8,10"    arr1[++n] = "2,4,16,14,4"    arr1[++n] = "3,1,9,18,11"    arr1[++n] = "12,14,17,18,20"    arr1[++n] = "7,1,3,9,5"    for (i=1; i<=n; i++) {      x = split(arr1[i],arr2,",")      if (x != n) {        printf("error: row %d has %d elements; S/B %d\n",i,x,n)        errors++        continue      }      for (j=1; j<i; j++) { # below main diagonal        sum_b += arr2[j]        cnt_b++      }      for (j=i+1; j<=n; j++) { # above main diagonal        sum_a += arr2[j]        cnt_a++      }      for (j=1; j<=i; j++) { # on main diagonal        if (j == i) {          sum_o += arr2[j]          cnt_o++        }      }    }    if (errors > 0) { exit(1) }    printf("%5g Sum of the %d elements below main diagonal\n",sum_b,cnt_b)    printf("%5g Sum of the %d elements above main diagonal\n",sum_a,cnt_a)    printf("%5g Sum of the %d elements on main diagonal\n",sum_o,cnt_o)    printf("%5g Sum of the %d elements in the matrix\n",sum_b+sum_a+sum_o,cnt_b+cnt_a+cnt_o)    exit(0)} `
Output:
```   69 Sum of the 10 elements below main diagonal
111 Sum of the 10 elements above main diagonal
37 Sum of the 5 elements on main diagonal
217 Sum of the 25 elements in the matrix
```

## BASIC

### BASIC256

Translation of: FreeBASIC
`arraybase 1dim diag = {{ 1, 3, 7, 8,10}, { 2, 4,16,14, 4}, { 3, 1, 9,18,11}, {12,14,17,18,20}, { 7, 1, 3, 9, 5}}ind = diag[?,]sumDiag = 0 for x = 1 to diag[?,]	for y = 1 to diag[,?]-ind		sumDiag += diag[x, y]	next y	ind -= 1next x print "Sum of elements below main diagonal of matrix is "; sumDiagend`

### FreeBASIC

`Dim As Integer diag(1 To 5, 1 To 5) = { _    { 1, 3, 7, 8,10}, _    { 2, 4,16,14, 4}, _    { 3, 1, 9,18,11}, _    {12,14,17,18,20}, _    { 7, 1, 3, 9, 5}}Dim As Integer lenDiag = Ubound(diag), ind = lenDiagDim As Integer sumDiag = 0, x, y For x = 1 To lenDiag    For y = 1 To lenDiag-ind        sumDiag += diag(x, y)    Next y    ind -= 1Next x Print "Sum of elements below main diagonal of matrix is"; sumDiagSleep`
Output:
`Sum of elements below main diagonal of matrix is 69`

### GW-BASIC

`10 DATA 1,3,7,8,1020 DATA 2,4,16,14,430 DATA 3,1,9,18,1140 DATA 12,14,17,18,2050 DATA 7,1,3,9,560 FOR ROW = 1 TO 570 FOR COL = 1 TO 580 READ N90 IF ROW > COL THEN SUM = SUM + N100 NEXT COL110 NEXT ROW120 PRINT SUM`
Output:
`69`

### QBasic

Works with: QBasic
Works with: QuickBasic version 4.5
Translation of: FreeBASIC
`DEFINT A-Z DIM diag(1 TO 5, 1 TO 5)lenDiag = UBOUND(diag)ind = lenDiagsumDiag = 0 FOR x = 1 TO lenDiag    FOR y = 1 TO lenDiag        READ diag(x, y)    NEXT yNEXT x FOR x = 1 TO lenDiag    FOR y = 1 TO lenDiag - ind        sumDiag = sumDiag + diag(x, y)    NEXT y    ind = ind - 1NEXT x PRINT "Sum of elements below main diagonal of matrix is"; sumDiagEND DATA 1, 3, 7, 8,10DATA 2, 4,16,14, 4DATA 3, 1, 9,18,11DATA 12,14,17,18,20DATA 7, 1, 3, 9, 5`

### True BASIC

Translation of: FreeBASIC
`DIM diag(5, 5)LET lenDiag = UBOUND(diag, 1)LET ind = lenDiagLET sumDiag = 0 DATA 1, 3, 7, 8,10DATA 2, 4,16,14, 4DATA 3, 1, 9,18,11DATA 12,14,17,18,20DATA 7, 1, 3, 9, 5 FOR x = 1 TO lenDiag    FOR y = 1 TO lenDiag        READ diag(x, y)    NEXT yNEXT x FOR x = 1 TO lenDiag    FOR y = 1 TO lenDiag - ind        LET sumDiag = sumDiag + diag(x, y)    NEXT y    LET ind = ind - 1NEXT x PRINT "Sum of elements below main diagonal of matrix:"; sumDiagEND`

### Yabasic

Translation of: FreeBASIC
`dim diag(5, 5)lenDiag = arraysize(diag(),1)ind = lenDiagsumDiag = 0 for x = 1 to lenDiag    for y = 1 to lenDiag        read diag(x, y)    next ynext x for x = 1 to lenDiag    for y = 1 to lenDiag-ind        sumDiag = sumDiag + diag(x, y)    next y    ind = ind - 1next x print "Sum of elements below main diagonal of matrix: ", sumDiagend data 1, 3, 7, 8,10data 2, 4,16,14, 4data 3, 1, 9,18,11data 12,14,17,18,20data 7, 1, 3, 9, 5`

## BQN

`SumBelowDiagonal ← +´∘⥊⊢×(>⌜´)∘(↕¨≢) matrix ← >⟨⟨ 1, 3, 7, 8,10⟩,           ⟨ 2, 4,16,14, 4⟩,           ⟨ 3, 1, 9,18,11⟩,           ⟨12,14,17,18,20⟩,           ⟨ 7, 1, 3, 9, 5⟩⟩ SumBelowDiagonal matrix`
Output:
`69`

## C

Interactive program which reads the matrix from a file :

` #include<stdlib.h>#include<stdio.h> typedef struct{	int rows,cols;	int** dataSet;}matrix; matrix readMatrix(char* dataFile){	FILE* fp = fopen(dataFile,"r");	matrix rosetta;	int i,j; 	fscanf(fp,"%d%d",&rosetta.rows,&rosetta.cols); 	rosetta.dataSet = (int**)malloc(rosetta.rows*sizeof(int*)); 	for(i=0;i<rosetta.rows;i++){		rosetta.dataSet[i] = (int*)malloc(rosetta.cols*sizeof(int));		for(j=0;j<rosetta.cols;j++)			fscanf(fp,"%d",&rosetta.dataSet[i][j]);	} 	fclose(fp);	return rosetta;} void printMatrix(matrix rosetta){	int i,j; 	for(i=0;i<rosetta.rows;i++){		printf("\n");		for(j=0;j<rosetta.cols;j++)			printf("%3d",rosetta.dataSet[i][j]);	}} int findSum(matrix rosetta){	int i,j,sum = 0; 	for(i=1;i<rosetta.rows;i++){		for(j=0;j<i;j++){			sum += rosetta.dataSet[i][j];		}	} 	return sum;} int main(int argC,char* argV[]){	if(argC!=2)		return printf("Usage : %s <filename>",argV[0]); 	matrix data = readMatrix(argV[1]); 	printf("\n\nMatrix is : \n\n");	printMatrix(data); 	printf("\n\nSum below main diagonal : %d",findSum(data)); 	return 0;} `

Input Data file, first row specifies rows and columns :

```5 5
1 3 7 8 10
2 4 16 14 4
3 1 9 18 11
12 14 17 18 20
7 1 3 9 5
```

And output follows :

Output:
```C:\My Projects\BGI>a.exe rosettaData.txt

Matrix is :

1  3  7  8 10
2  4 16 14  4
3  1  9 18 11
12 14 17 18 20
7  1  3  9  5

Sum below main diagonal : 69
```

## C++

`#include <iostream>#include <vector> template<typename T>T sum_below_diagonal(const std::vector<std::vector<T>>& matrix) {    T sum = 0;    for (std::size_t y = 0; y < matrix.size(); y++)        for (std::size_t x = 0; x < matrix[y].size() && x < y; x++)            sum += matrix[y][x];    return sum;} int main() {    std::vector<std::vector<int>> matrix = {        {1,3,7,8,10},        {2,4,16,14,4},        {3,1,9,18,11},        {12,14,17,18,20},        {7,1,3,9,5}    };     std::cout << sum_below_diagonal(matrix) << std::endl;    return 0;}`
Output:
`69`

## Excel

### LAMBDA

Binding the name matrixTriangle to the following lambda expression in the Name Manager of the Excel WorkBook:

`=LAMBDA(isUpper,    LAMBDA(matrix,        LET(            nCols, COLUMNS(matrix),            nRows, ROWS(matrix),            ixs, SEQUENCE(nRows, nCols, 0, 1),            x, MOD(ixs, nCols),            y, QUOTIENT(ixs, nRows),             IF(nCols=nRows,                LET(                    p, LAMBDA(x, y,                        IF(isUpper, x > y, x < y)                    ),                     IF(p(x, y),                         INDEX(matrix, 1 + y, 1 + x),                         0                    )                ),                "Matrix not square"            )        )    ))`
Output:

The formulae in cells B2 and B9 define and populate the matrices which fill the ranges B2:F6 and B9:F12

(The formula in B9 differs from that in B2 only in the first (Boolean) argument)

 =matrixTriangle(FALSE)(B16#) fx A B C D E F 1 2 Lower triangle: 0 0 0 0 0 3 2 0 0 0 0 4 3 1 0 0 0 5 12 14 17 0 0 6 7 1 3 9 0 7 Sum 69 8 9 Upper triangle: 0 3 7 8 10 10 0 0 16 14 4 11 0 0 0 18 11 12 0 0 0 0 20 13 0 0 0 0 0 14 Sum 111 15 16 Full matrix 1 3 7 8 10 17 2 4 16 14 4 18 3 1 9 18 11 19 12 14 17 18 20 20 7 1 3 9 5

## F#

` // Sum below leading diagnal. Nigel Galloway: July 21st., 2021let _,n=[[ 1; 3; 7; 8;10];         [ 2; 4;16;14; 4];         [ 3; 1; 9;18;11];         [12;14;17;18;20];         [ 7; 1; 3; 9; 5]]|>List.fold(fun(n,g) i->let i,_=i|>List.splitAt n in (n+1,g+(i|>List.sum)))(0,0) in printfn "%d" n `
Output:
```69
```

## Factor

Works with: Factor version 0.99 2021-06-02
`USING: kernel math math.matrices prettyprint sequences ; : sum-below-diagonal ( matrix -- sum )    dup square-matrix? [ "Matrix must be square." throw ] unless    0 swap [ head sum + ] each-index ; {    { 1 3 7 8 10 }    { 2 4 16 14 4 }    { 3 1 9 18 11 }    { 12 14 17 18 20 }    { 7 1 3 9 5 }} sum-below-diagonal .`
Output:
```69
```

## Go

`package main import (    "fmt"    "log") func main() {    m := [][]int{        {1, 3, 7, 8, 10},        {2, 4, 16, 14, 4},        {3, 1, 9, 18, 11},        {12, 14, 17, 18, 20},        {7, 1, 3, 9, 5},    }    if len(m) != len(m[0]) {        log.Fatal("Matrix must be square.")    }    sum := 0    for i := 1; i < len(m); i++ {        for j := 0; j < i; j++ {            sum = sum + m[i][j]        }    }    fmt.Println("Sum of elements below main diagonal is", sum)}`
Output:
```Sum of elements below main diagonal is 69
```

Defining both upper and lower triangle of a square matrix:

`----------------- UPPER OR LOWER TRIANGLE ---------------- matrixTriangle :: Bool -> [[a]] -> Either String [[a]]matrixTriangle upper matrix  | upper = go drop id  | otherwise = go take pred  where    go f g      | isSquare matrix =        (Right . snd) \$          foldr            (\xs (n, rows) -> (pred n, f n xs : rows))            (g \$ length matrix, [])            matrix      | otherwise = Left "Defined only for a square matrix." isSquare :: [[a]] -> BoolisSquare rows = all ((n ==) . length) rows  where    n = length rows --------------------------- TEST -------------------------main :: IO ()main =  mapM_ putStrLn \$    zipWith      ( flip ((<>) . (<> " triangle:\n\t"))          . either id (show . sum . concat)      )      ( [matrixTriangle] <*> [False, True]          <*> [ [ [1, 3, 7, 8, 10],                  [2, 4, 16, 14, 4],                  [3, 1, 9, 18, 11],                  [12, 14, 17, 18, 20],                  [7, 1, 3, 9, 5]                ]              ]      )      ["Lower", "Upper"]`
Output:
```Lower triangle:
69
Upper triangle:
111```

## J

`sum_below_diagonal =: [:+/@,[*>/[email protected]@#`
Output:
```   mat
1  3  7  8 10
2  4 16 14  4
3  1  9 18 11
12 14 17 18 20
7  1  3  9  5
sum_below_diagonal mat
69```

## JavaScript

Defining the lower triangle of a square matrix.

`(() => {    "use strict";     // -------- LOWER TRIANGLE OF A SQUARE MATRIX --------     // lowerTriangle :: [[a]] -> Either String [[a]]    const lowerTriangle = matrix =>        // Either a message, if the matrix is not square,        // or the lower triangle of the matrix.        isSquare(matrix) ? (            Right(                matrix.reduce(                    ([n, rows], xs) => [                        1 + n,                        rows.concat([xs.slice(0, n)])                    ],                    [0, []]                )[1]            )        ) : Left("Not a square matrix");      // isSquare :: [[a]] -> Bool    const isSquare = rows => {        // True if the length of every row in the matrix        // matches the number of rows in the matrix.        const n = rows.length;         return rows.every(x => n === x.length);    };     // ---------------------- TEST -----------------------    const main = () =>        either(            msg => `Lower triangle undefined :: \${msg}`        )(            rows => sum([].concat(...rows))        )(            lowerTriangle([                [1, 3, 7, 8, 10],                [2, 4, 16, 14, 4],                [3, 1, 9, 18, 11],                [12, 14, 17, 18, 20],                [7, 1, 3, 9, 5]            ])        );     // --------------------- GENERIC ---------------------     // Left :: a -> Either a b    const Left = x => ({        type: "Either",        Left: x    });      // Right :: b -> Either a b    const Right = x => ({        type: "Either",        Right: x    });      // either :: (a -> c) -> (b -> c) -> Either a b -> c    const either = fl =>        // Application of the function fl to the        // contents of any Left value in e, or        // the application of fr to its Right value.        fr => e => e.Left ? (            fl(e.Left)        ) : fr(e.Right);      // sum :: [Num] -> Num    const sum = xs =>        // The numeric sum of all values in xs.        xs.reduce((a, x) => a + x, 0);     // MAIN ---    return main();})();`
Output:
`69`

## jq

Works with: jq

Works with gojq, the Go implementation of jq

` def add(s): reduce s as \$x (null; . + \$x); # input: a square matrixdef sum_below_diagonal:  add( range(0;length) as \$i | .[\$i][:\$i][] ) ; `

`  [[1,3,7,8,10],   [2,4,16,14,4],   [3,1,9,18,11],   [12,14,17,18,20],   [7,1,3,9,5]]  | sum_below_diagonal`
Output:
```69
```

## Julia

The tril function is part of Julia's built-in LinearAlgebra package. tril(A) includes the main diagonal and the components of the matrix A to the left and below the main diagonal. tril(A, -1) returns the lower triangular elements of A excluding the main diagonal. The excluded elements of the matrix are set to 0.

`using LinearAlgebra A = [ 1  3  7  8 10;      2  4 16 14  4;      3  1  9 18 11;     12 14 17 18 20;      7  1  3  9  5 ] @show tril(A) @show tril(A, -1) @show sum(tril(A, -1))  # 69 `
Output:
```
tril(A) = [1 0 0 0 0; 2 4 0 0 0; 3 1 9 0 0; 12 14 17 18 0; 7 1 3 9 5]
tril(A, -1) = [0 0 0 0 0; 2 0 0 0 0; 3 1 0 0 0; 12 14 17 0 0; 7 1 3 9 0]
sum(tril(A, -1)) = 69

```

## Mathematica/Wolfram Language

`m = {{1, 3, 7, 8, 10}, {2, 4, 16, 14, 4}, {3, 1, 9, 18, 11}, {12, 14, 17, 18, 20}, {7, 1, 3, 9, 5}};Total[LowerTriangularize[m, -1], 2]`
Output:
`69`

## MiniZinc

` % Sum below leading diagnal. Nigel Galloway: July 22nd., 2021array [1..5,1..5] of int: N=[|1,3,7,8,10|2,4,16,14,4|3,1,9,18,11|12,14,17,18,20|7,1,3,9,5|];int: res=sum(n,g in 1..5 where n>g)(N[n,g]);output([show(res)]) `
Output:
```69
----------
```

## Nim

We use a generic definition for the square matrix type. The compiler insures that the matrix we provide is actually square.

`type SquareMatrix[T: SomeNumber; N: static Positive] = array[N, array[N, T]] func sumBelowDiagonal[T, N](m: SquareMatrix[T, N]): T =  for i in 1..<N:    for j in 0..<i:      result += m[i][j] const M = [[ 1,  3,  7,  8, 10],           [ 2,  4, 16, 14,  4],           [ 3,  1,  9, 18, 11],           [12, 14, 17, 18, 20],           [ 7,  1,  3,  9,  5]] echo sumBelowDiagonal(M)`
Output:
`69`

## Perl

`#!/usr/bin/perl use strict;use warnings;use List::Util qw( sum ); my \$matrix =  [[1,3,7,8,10],  [2,4,16,14,4],  [3,1,9,18,11],  [12,14,17,18,20],  [7,1,3,9,5]]; my \$lowersum = sum map @{ \$matrix->[\$_] }[0 .. \$_ - 1], 1 .. \$#\$matrix;print "lower sum = \$lowersum\n";`
Output:
```lower sum = 69
```

## Phix

```constant M = {{ 1,  3,  7,  8, 10},
{ 2,  4, 16, 14,  4},
{ 3,  1,  9, 18, 11},
{12, 14, 17, 18, 20},
{ 7,  1,  3,  9,  5}}
atom res = 0
integer height = length(M)
for row=1 to height do
integer width = length(M[row])
if width!=height then crash("not square") end if
for col=1 to row-1 do
res += M[row][col]
end for
end for
?res
```

You could of course start row from 2 and get the same result, for row==1 the col loop iterates zero times.
Without the checks for square M expect (when not square) wrong/partial answers for height<=width+1, and (still human readable) runtime crashes for height>width+1.

Output:
```69
```

## PL/I

` trap: procedure options (main);      /* 17 December 2021 */   declare n fixed binary;   get (n);   put ('The order of the matrix is ' || trim(n));   begin;      declare A (n,n) fixed binary;      declare sum fixed binary;      declare (i, j) fixed binary;       get (A);      sum = 0;      do i = 2 to n;         do j = 1 to i-1;            sum = sum + a(i,j);         end;      end;      put edit (A) (skip, (n) f(4) );      put skip data (sum);   end;end trap; `
Output:
```The order of the matrix is 5

1   3   7   8  10
2   4  16  14   4
3   1   9  18  11
12  14  17  18  20
7   1   3   9   5
SUM=       69;
```

## PL/M

This can be compiled with the original 8080 PL/M compiler and run under CP/M or an emulator/clone.

`100H: /* SUM THE ELEMENTS BELOW THE MAIN DIAGONAL OF A MATRIX                */    /* CP/M BDOS SYSTEM CALL, IGNORE THE RETURN VALUE                         */   BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5;     END;   PR\$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S );      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;    /* RETURNS THE SUM OF THE ELEMENTS BELOW THE MAIN DIAGONAL OF MX          */   /* MX WOULD BE DECLARED AS ''( UB, UB )ADDRESS'' IF PL/M SUPPORTED        */   /* 2-DIMENSIONAL ARRAYS, IT DOESN'T SO MX MUST ACTULLY BE DECLARED        */   /* ''( UB * UB )ADDRESS'' - EXCEPT THE BOUND MUST BE A CONSTANT, NOT AN   */   /* EXPRESSION                                                             */   /* NOTE ''ADDRESS'' MEANS UNSIGNED 16-BIT QUANTITY, WHICH CAN BE USED FOR */   /* OTHER PURPOSES THAN JUST POINTERS                                      */   LOWER\$SUM: PROCEDURE( MX, UB )ADDRESS;      DECLARE ( MX, UB ) ADDRESS;      DECLARE ( SUM, R, C, STRIDE, R\$PTR ) ADDRESS;      DECLARE M\$PTR ADDRESS, M\$VALUE BASED M\$PTR ADDRESS;      SUM    = 0;      STRIDE = UB + UB;      R\$PTR  = MX + STRIDE;      /* ADDRESS OF ROW 1 ( THE FIRST ROW IS 0 )  */      DO R = 1 TO UB - 1;         M\$PTR = R\$PTR;         DO C = 0 TO R - 1;            SUM = SUM + M\$VALUE;            M\$PTR = M\$PTR + 2;         END;         R\$PTR = R\$PTR + STRIDE; /* ADDRESS OF THE NEXT ROW                  */      END;      RETURN SUM;   END LOWER\$SUM ;    /* TASK TEST CASE                                                         */   DECLARE T ( 25 )ADDRESS                   INITIAL(  1,  3,  7,  8, 10                          ,  2,  4, 16, 14,  4                          ,  3,  1,  9, 18, 11                          , 12, 14, 17, 18, 20                          ,  7,  1,  3,  9,  5                          );   CALL PR\$NUMBER( LOWER\$SUM( .T, 5 ) ); EOF`
Output:
```69
```

## Python

`from numpy import array, tril, sum A = [[1,3,7,8,10],    [2,4,16,14,4],    [3,1,9,18,11],    [12,14,17,18,20],    [7,1,3,9,5]] print(sum(tril(A, -1)))   # 69`

Or, defining the lower triangle for ourselves:

`'''Lower triangle of a matrix''' from itertools import chain, islicefrom functools import reduce  # lowerTriangle :: [[a]] -> None | [[a]]def lowerTriangle(matrix):    '''Either None, if the matrix is not square, or       the rows of the matrix, each containing only       those values that form part of the lower triangle.    '''    def go(n_rows, xs):        n, rows = n_rows        return 1 + n, rows + [list(islice(xs, n))]     return reduce(        go,        matrix,        (0, [])    )[1] if isSquare(matrix) else None  # isSquare :: [[a]] -> Booldef isSquare(matrix):    '''True if all rows of the matrix share       the length of the matrix itself.    '''    n = len(matrix)    return all([n == len(x) for x in matrix])  # ------------------------- TEST -------------------------# main :: IO ()def main():    '''Sum of integers in the lower triangle of a matrix.    '''    rows = lowerTriangle([        [1, 3, 7, 8, 10],        [2, 4, 16, 14, 4],        [3, 1, 9, 18, 11],        [12, 14, 17, 18, 20],        [7, 1, 3, 9, 5]    ])     print(        "Not a square matrix." if None is rows else (            sum(chain(*rows))        )    ) # MAIN ---if __name__ == '__main__':    main()`
Output:
`69`

## R

R has lots of native matrix support, so this is trivial.

`mat <- rbind(c(1,3,7,8,10),             c(2,4,16,14,4),             c(3,1,9,18,11),             c(12,14,17,18,20),             c(7,1,3,9,5))print(sum(mat[lower.tri(mat)]))`
Output:
`[1] 69`

## Raku

`sub lower-triangle-sum (@matrix) { sum flat (1..@matrix).map( { @matrix[^\$_]»[^(\$_-1)] } )»[*-1] } say lower-triangle-sum [    [  1,  3,  7,  8, 10 ],    [  2,  4, 16, 14,  4 ],    [  3,  1,  9, 18, 11 ],    [ 12, 14, 17, 18, 20 ],    [  7,  1,  3,  9,  5 ]];`
Output:
`69`

## REXX

### version 1

`/* REXX */ml ='1 3 7 8 10 2 4 16 14 4 3 1 9 18 11 12 14 17 18 20 7 1 3 9 5'Do i=1 To 5  Do j=1 To 5    Parse Var ml m.i.j ml    End  End l=''Do i=1 To 5  Do j=1 To 5    l=l right(m.i.j,2)    End  Say l  l=''  End sum=0Do i=2 To 5  Do j=1 To i-1    sum=sum+m.i.j    End  EndSay 'Sum below main diagonal:' sum`
```
1  3  7  8 10
2  4 16 14  4
3  1  9 18 11
12 14 17 18 20
7  1  3  9  5
Sum below main diagonal: 69 ```

### version 2

This REXX version makes no assumption about the size of the matrix,   and it determines the maximum width of any
matrix element   (instead of assuming a width that might not properly show the true value of an element).

`/*REXX pgm finds & shows the sum of elements below the main diagonal of a square matrix.*/\$= '1 3 7 8 10 2 4 16 14 4 3 1 9 18 11 12 14 17 18 20 7 1 3 9 5';       #= words(\$)     do siz=1  while siz*siz<#;  end             /*determine the size of the matrix.    */w= 0                                             /*W:  the maximum width any any element*/     do j=1  for #;         parse var \$  @..j  \$ /*obtain a number of the array (list). */     w= max(w, length(@..j))                     /*examine each element for its width.  */     end   /*j*/                                 /* [↑] this is aligning matrix elements*/s= 0;                       z= 0                 /*initialize the sum  [S]  to zero.    */     do      r=1  for siz;  _= left('', 12)      /*_:  contains a row of matrix elements*/          do c=1  for siz;  z= z + 1;  @.z= @..z /*get a  number  of the    "      "    */          _= _  right(@.z, w)                    /*build a row of elements for display. */          if c<r  then s= s + @.z                /*add a  "lower element"  to the sum.  */          end   /*r*/     say _                                       /*display a row of the matrix to term. */     end        /*c*/say 'sum of elements below main diagonal is: ' s /*stick a fork in it,  we're all done. */`
output   when using the internal default input:
```              1  3  7  8 10
2  4 16 14  4
3  1  9 18 11
12 14 17 18 20
7  1  3  9  5
sum of elements below main diagonal is:  69
```

## Ring

` see "working..." + nlsee "Sum of elements below main diagonal of matrix:" + nldiag = [[1,3,7,8,10],        [2,4,16,14,4],        [3,1,9,18,11],        [12,14,17,18,20],        [7,1,3,9,5]] lenDiag = len(diag)ind = lenDiagsumDiag = 0 for n=1 to lenDiag    for m=1 to lenDiag-ind        sumDiag += diag[n][m]    next    ind--next see "" + sumDiag + nlsee "done..." + nl `
Output:
```working...
Sum of elements below main diagonal of matrix:
69
done...
```

## Ruby

`arr = [   [ 1,  3,  7,  8, 10],   [ 2,  4, 16, 14,  4],   [ 3,  1,  9, 18, 11],   [12, 14, 17, 18, 20],   [ 7,  1,  3,  9,  5]]p  arr.each_with_index.sum {|row, x| row[0, x].sum} `
Output:
```69
```

## Seed7

`\$ include "seed7_05.s7i"; const proc: main is func  local    var integer: sum is 0;    var integer: i is 0;    var integer: j is 0;    const array array integer: m is [] ([] ( 1,  3,  7,  8, 10),                                        [] ( 2,  4, 16, 14,  4),                                        [] ( 3,  1,  9, 18, 11),                                        [] (12, 14, 17, 18, 20),                                        [] ( 7,  1,  3,  9,  5));  begin    for i range 2 to length(m) do      for j range 1 to i - 1 do        sum +:= m[i][j];      end for;    end for;    writeln(sum);  end func;`
Output:
```69
```

## Wren

`var m = [    [ 1,  3,  7,  8, 10],    [ 2,  4, 16, 14,  4],    [ 3,  1,  9, 18, 11],    [12, 14, 17, 18, 20],    [ 7,  1,  3,  9,  5]]if (m.count != m[0].count) Fiber.abort("Matrix must be square.")var sum = 0for (i in 1...m.count) {   for (j in 0...i) {       sum = sum + m[i][j]  }}System.print("Sum of elements below main diagonal is %(sum).")`
Output:
```Sum of elements below main diagonal is 69.
```

## XPL0

`int Mat, X, Y, Sum;[Mat:=  [[1,3,7,8,10],        [2,4,16,14,4],        [3,1,9,18,11],        [12,14,17,18,20],        [7,1,3,9,5]];Sum:= 0;for Y:= 0 to 4 do  for X:= 0 to 4 do    if Y > X then      Sum:= Sum + Mat(Y,X);IntOut(0, Sum);]`
Output:
```69
```