Matrix with two diagonals: Difference between revisions

Line 7:

=={{header|Ada}}==

<~~lang~~ ~~Ada~~>with Ada.Text_Io; use Ada.Text_Io;

<syntaxhighlight lang="ada">with Ada.Text_Io; use Ada.Text_Io;

with Ada.Command_Line;

Line 46:

Put_Line ("Usage: ./matrix_with_diagonals <side-length>");

end Matrix_With_Diagonals;</~~lang~~>

end Matrix_With_Diagonals;</syntaxhighlight>

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

<~~lang~~ algol68>BEGIN # draw a matrix with 1s on the diagonals and 0s elsewhere #

<syntaxhighlight lang="algol68">BEGIN # draw a matrix with 1s on the diagonals and 0s elsewhere #

# draws a matrix with height and width = n with 1s on the diagonals #

PROC draw 2 diagonals = ( INT n )VOID:

Line 68:

print( ( newline ) );

draw 2 diagonals( 11 )

END</~~lang~~>

END</syntaxhighlight>

<pre>

Line 97:

=={{header|APL}}==

<~~lang~~ apl>twoDiagonals ← (⌽∨⊢)∘.=⍨∘⍳

<syntaxhighlight lang="apl">twoDiagonals ← (⌽∨⊢)∘.=⍨∘⍳

twoDiagonals¨ 10 11</~~lang~~>

twoDiagonals¨ 10 11</syntaxhighlight>

<pre> 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1

Line 113:

=={{header|AppleScript}}==

===Procedural===

<~~lang~~ applescript>on twoDiagonalMatrix(n)

<syntaxhighlight lang="applescript">on twoDiagonalMatrix(n)

if (n < 2) then error "twoDiagonalMatrix() handler: parameter must be > 1."

Line 151:

return linefeed & matrixToText(twoDiagonalMatrix(7), space) & ¬

(linefeed & linefeed & matrixToText(twoDiagonalMatrix(8), space))</~~lang~~>

(linefeed & linefeed & matrixToText(twoDiagonalMatrix(8), space))</syntaxhighlight>

<~~lang~~ applescript>"

<syntaxhighlight lang="applescript">"

1 0 0 0 0 0 1

0 1 0 0 0 1 0

Line 170:

0 0 1 0 0 1 0 0

0 1 0 0 0 0 1 0

1 0 0 0 0 0 0 1"</~~lang~~>

1 0 0 0 0 0 0 1"</syntaxhighlight>

===Functional===

<~~lang~~ applescript>---------------- MATRIX WITH TWO DIAGONALS ---------------

<syntaxhighlight lang="applescript">---------------- MATRIX WITH TWO DIAGONALS ---------------

-- bothDiagonals :: Int -> [[Int]]

Line 312:

set my text item delimiters to dlm

return s

end unwords</~~lang~~>

end unwords</syntaxhighlight>

<pre>1 0 0 0 0 0 1

Line 333:

=={{header|Arturo}}==

<~~lang~~ rebol>drawSquare: function [side][

<syntaxhighlight lang="rebol">drawSquare: function [side][

loop 1..side 'x ->

print map 1..side 'y [

Line 342:

drawSquare 6

print ""

drawSquare 9</~~lang~~>

drawSquare 9</syntaxhighlight>

Line 364:

=={{header|AutoHotkey}}==

<~~lang~~ ~~AutoHotkey~~>for i, v in [8, 9]

<syntaxhighlight lang="autohotkey">for i, v in [8, 9]

result .= "Matrix Size: " v "*" v "`n" matrix2txt(diagonalMatrix(v)) "`n"

MsgBox % result

Line 386:

}

return result

}</~~lang~~>

}</syntaxhighlight>

<pre>Matrix Size: 8*8

Line 410:

=={{header|AWK}}==

# syntax: GAWK -f MATRIX_WITH_TWO_DIAGONALS.AWK

BEGIN {

Line 425:

exit(0)

}

</syntaxhighlight>

</lang>

<pre>

Line 445:

=={{header|Basic}}==

<~~lang~~ qbasic>100 REM

<syntaxhighlight lang="qbasic">100 REM

110 REM DIAGONAL-DIAGONAL MATRIX

120 REM

Line 467:

290 NEXT I

300 END

</syntaxhighlight>

</lang>

<pre> 1 0 0 0 0 0 1

Line 479:

=={{header|BCPL}}==

<~~lang~~ bcpl>get "libhdr"

<syntaxhighlight lang="bcpl">get "libhdr"

let diagonals(size) be

Line 492:

wrch('*N')

diagonals(10)

$)</~~lang~~>

$)</syntaxhighlight>

<pre>1 0 0 0 0 0 0 0 1

Line 517:

=={{header|C}}==

<~~lang~~ c>#include <stdio.h>

<syntaxhighlight lang="c">#include <stdio.h>

void specialMatrix(unsigned int n) {

Line 538:

specialMatrix(11); // odd n

return 0;

}</~~lang~~>

}</syntaxhighlight>

Line 567:

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

<~~lang~~ cpp>#include <concepts>

<syntaxhighlight lang="cpp">#include <concepts>

#include <iostream>

Line 597:

}

</syntaxhighlight>

</lang>

<pre> 1 0 0 0 0 0 0 1

Line 620:

=={{header|CLU}}==

<~~lang~~ clu>matrix = array[array[int]]

<syntaxhighlight lang="clu">matrix = array[array[int]]

diagonals = proc (size: int) returns (matrix)

Line 653:

stream$putl(po, "")

print_matrix(po, diagonals(10))

end start_up</~~lang~~>

end start_up</syntaxhighlight>

<pre> 1 0 0 0 0 0 0 0 1

Line 677:

=={{header|Draco}}==

<~~lang~~ draco>proc setDiagonals([*,*] byte matrix) void:

<syntaxhighlight lang="draco">proc setDiagonals([*,*] byte matrix) void:

word x, y, width, height;

width := dim(matrix, 1);

Line 714:

setDiagonals(m_even);

printMatrix(m_even)

corp</~~lang~~>

corp</syntaxhighlight>

<pre> 1 0 0 0 0 0 0 0 1

Line 747:

<~~lang~~ lisp>TwoDiagonalMatrix

<syntaxhighlight lang="lisp">TwoDiagonalMatrix

=LAMBDA(n,

LET(

Line 759:

)

)</~~lang~~>

)</syntaxhighlight>

The formulae in cells A2 and B2 populate the whole of each adjacent matrix.

Line 970:

Binding the name ''bothDiagonalMatrix'' in the Excel Name Manager:

<~~lang~~ lisp>bothDiagonalMatrix

<syntaxhighlight lang="lisp">bothDiagonalMatrix

=LAMBDA(n,

MAKEARRAY(

Line 982:

)

)</~~lang~~>

)</syntaxhighlight>

{| class="wikitable"

Line 1,189:

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

<~~lang~~ fsharp>

// Matrix with two diagonals. Nigel Galloway: February 17th., 2022

let m11 m=Array2D.init m m (fun n g->if n=g || n+g=m-1 then 1 else 0)

printfn "%A\n\n%A" (m11 5) (m11 6)

</syntaxhighlight>

</lang>

<pre>

Line 1,212:

=={{header|Factor}}==

<~~lang~~ factor>USING: io kernel math math.matrices prettyprint ;

<syntaxhighlight lang="factor">USING: io kernel math math.matrices prettyprint ;

: <x-matrix> ( n -- matrix )

Line 1,218:

6 <x-matrix> simple-table. nl

7 <x-matrix> simple-table.</~~lang~~>

7 <x-matrix> simple-table.</syntaxhighlight>

<pre>

Line 1,240:

=={{header|FreeBASIC}}==

===Text based===

<~~lang~~ freebasic>Sub twoDiagonalMatrix(n As Integer)

<syntaxhighlight lang="freebasic">Sub twoDiagonalMatrix(n As Integer)

For i As Integer = 1 To n

For j As Integer = 1 To n

Line 1,252:

Print

twoDiagonalMatrix(7)

Sleep</~~lang~~>

Sleep</syntaxhighlight>

<pre>1 0 0 0 0 1

Line 1,270:

===Graphical===

<~~lang~~ freebasic>Dim As Integer n = 8, size = 60 * n + 70

<syntaxhighlight lang="freebasic">Dim As Integer n = 8, size = 60 * n + 70

Screenres size, size, 24

Cls

Line 1,291:

Next x

Bsave "twoDiagonalMatrix.bmp",0

Sleep</~~lang~~>

Sleep</syntaxhighlight>

https://www.dropbox.com/s/ph9r28gpkp8ao8n/twoDiagonalMatrix.bmp?dl=0

Line 1,300:

Fortran stores data in columns. Therefore, it should be checked whether instead of filling the matrix row by row (as below) it would be better to do it column by column. The profit would be cache hit optimization, better communication between CPU and RAM. Fortran allows you to zero the entire array, such as the a array below, simply by substituting a = 0. Unfortunately, an array 100x100 (that is, the choosen maximum size) would be filled with zeros even if, as in the example, we would need a much smaller array. You can also eliminate the variables j1 and j2 by replacing them with i and n - i + 1 respectively, but the source code would be slightly less readable.

<~~lang~~ ~~Fortran~~>program prog

<syntaxhighlight lang="fortran">program prog

dimension a(100, 100)

Line 1,323:

end

</syntaxhighlight>

</lang>

<pre>

Line 1,337:

Fortran is the oldest high-level programming language. It is constantly evolving and unfortunately there are no longer (or at least I do not have) computers on which to test whether the program works in the old Fortran IV or an even older dialect. The example below should be in Fortran IV, but unfortunately it was tested with a modern Fortran 2018 compiler, so even in legacy mode it is not Fortran IV but Fortran 77. However, it seems that it should work on CDC6000 mainframe ... if someone obviously has CDC6000.

<~~lang~~ fortran>C DIAGONAL-DIAGONAL MATRIX IN FORTRAN 77

<syntaxhighlight lang="fortran">C DIAGONAL-DIAGONAL MATRIX IN FORTRAN 77

PROGRAM PROG

Line 1,353:

20 PRINT *, (A(I, J), J=1,N)

END</~~lang~~>

END</syntaxhighlight>

=={{header|Go}}==

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import "fmt"

Line 1,378:

fmt.Println()

specialMatrix(9) // odd n

}</~~lang~~>

}</syntaxhighlight>

Line 1,403:

=={{header|Haskell}}==

<~~lang~~ haskell>---------------- MATRIX WITH TWO DIAGONALS ---------------

<syntaxhighlight lang="haskell">---------------- MATRIX WITH TWO DIAGONALS ---------------

twoDiagonalMatrix :: Int -> [[Int]]

Line 1,420:

unlines . fmap (((' ' :) . show) =<<)

. twoDiagonalMatrix

<$> [7, 8]</~~lang~~>

<$> [7, 8]</syntaxhighlight>

Or, in the form of a list comprehension:

<~~lang~~ haskell>-------------- MATRIX WITH TWO DIAGONALS ---------------

<syntaxhighlight lang="haskell">-------------- MATRIX WITH TWO DIAGONALS ---------------

twoDiagonalMatrix :: Int -> [[Int]]

Line 1,441:

unlines . fmap (((' ' :) . show) =<<)

. twoDiagonalMatrix

<$> [7, 8]</~~lang~~>

<$> [7, 8]</syntaxhighlight>

<pre> 1 0 0 0 0 0 1

Line 1,462:

and in terms of the Data.Matrix library:

<~~lang~~ haskell>import Data.Matrix

<syntaxhighlight lang="haskell">import Data.Matrix

twoDiagonals :: Int -> Matrix Int

Line 1,473:

main :: IO ()

main =

mapM_ print $ twoDiagonals <$> [7, 8]</~~lang~~>

mapM_ print $ twoDiagonals <$> [7, 8]</syntaxhighlight>

<pre>┌ ┐

Line 1,499:

Implementation:

<~~lang~~ J>task=: {{(+.|.)=i.y}}</~~lang~~>

In other words, generate an order n identity matrix, flip it and (treating it as a bit matrix) OR the two matrices.

Line 1,505:

Some examples:

<~~lang~~ J> task 2

<syntaxhighlight lang="j"> task 2

1 1

Line 1,529:

0 0 1 1 0 0

0 1 0 0 1 0

1 0 0 0 0 1</~~lang~~>

1 0 0 0 0 1</syntaxhighlight>

=={{header|Java}}==

The "Java philosophy" is the object-oriented paradigm. The example solution given below is therefore somewhat incomplete. We should first declare the matrix as an interface (or abstract class), then create a whole hierarchy of subclasses where DiagonalDiagonalMatrix would be a subclass of SquareMatrix or something like that. Of course, it's a gigantic job, but as a result we would have a library competing with Matlab / Octave etc., compliant with SOLID principles.

<~~lang~~ java>package example.diagdiag;

<syntaxhighlight lang="java">package example.diagdiag;

public class Program {

Line 1,588:

}

}</~~lang~~>

}</syntaxhighlight>

<pre> 1.0 0.0 0.0 0.0 0.0 0.0 1.0

Line 1,599:

=={{header|JavaScript}}==

<~~lang~~ javascript>(() => {

<syntaxhighlight lang="javascript">(() => {

"use strict";

Line 1,647:

// MAIN --

return main();

})();</~~lang~~>

})();</syntaxhighlight>

Or, in terms of a more general matrix function:

<~~lang~~ javascript>(() => {

<syntaxhighlight lang="javascript">(() => {

"use strict";

Line 1,707:

// MAIN ---

return main();

})();</~~lang~~>

})();</syntaxhighlight>

<pre>1 0 0 0 0 0 1

Line 1,729:

'''Works with gojq, the Go implementation of jq'''

<~~lang~~ jq>def bidiagonal_matrix:

<syntaxhighlight lang="jq">def bidiagonal_matrix:

. as $n

| [range(0; $n) | 0] as $z

Line 1,736:

def display:

map(join(" ")) | join("\n");</~~lang~~>

map(join(" ")) | join("\n");</syntaxhighlight>

'''Example'''

<lang jq>9|bidiagonal_matrix|display</~~lang~~>

<syntaxhighlight lang="jq">9|bidiagonal_matrix|display</syntaxhighlight>

<pre>

Line 1,753:

=={{header|Julia}}==

<~~lang~~ julia>

julia> twodiagonalmat(n) = [Int(i == j || i == n - j + 1) for j in 1:n, i in 1:n]

twodiagonalmat (generic function with 1 method)

Line 1,786:

0 1 0 1 0

1 0 0 0 1

</syntaxhighlight>

</lang>

=== Sparse matrix version ===

<~~lang~~ julia>julia> using LinearAlgebra

<syntaxhighlight lang="julia">julia> using LinearAlgebra

julia> twodiagonalsparse(n) = I(n) .| rotl90(I(n))

Line 1,813:

⋅ 1 ⋅ ⋅ ⋅ ⋅ 1 ⋅

1 ⋅ ⋅ ⋅ ⋅ ⋅ ⋅ 1

</syntaxhighlight>

</lang>

=={{header|Matlab}}==

<~~lang~~ ~~Matlab~~>function A = diagdiag(N, sparse)

<syntaxhighlight lang="matlab">function A = diagdiag(N, sparse)

% Create an diagonal-diagonal square matrix.

%

Line 1,843:

A = fliplr(A);

A(1:N+1:end) = 1;

end</~~lang~~>

end</syntaxhighlight>

<pre>

Line 1,880:

=={{header|Pascal}}==

<~~lang~~ pascal>program diagonaldiagonal;

<syntaxhighlight lang="pascal">program diagonaldiagonal;

const N = 7;

type

Line 1,905:

end

end.

</syntaxhighlight>

</lang>

<pre> 1 0 0 0 0 0 1

Line 1,918:

=={{header|Perl}}==

===Strings===

<~~lang~~ perl>#!/usr/bin/perl

<syntaxhighlight lang="perl">#!/usr/bin/perl

use strict; #https://rosettacode.org/wiki/Matrix_with_two_diagonals

Line 1,931:

1 while s/(?<=1...{$n})0/1/s or s/(?<=2.{$n})[01]/2/s;

return tr/2/1/r =~ s/\B/ /gr;

}</~~lang~~>

}</syntaxhighlight>

<pre>1 0 0 0 0 0 0 0 0 1

Line 1,957:

===Numbers===

<~~lang~~ perl>use strict;

<syntaxhighlight lang="perl">use strict;

use warnings;

use feature 'say';

Line 1,973:

say join ' ', @$_ for dual_diagonal(4); say '';

say join ' ', @$_ for dual_diagonal(5);

</syntaxhighlight>

</lang>

<pre>1 0 0 1

Line 1,989:

===numbers===

Tee hee, pick the bones out of this one. ''Lovely.''

with javascript_semantics

for n=6 to 7 do

pp(apply(true,reinstate,{repeat(repeat(0,n),n),apply(true,sq_mul,{tagset(n),{{1,-1}}}),{{1,1}}}),{pp_Nest,1})

end for

<pre>

Line 2,012:

</pre>

Slightly saner, shows sackly same stuff:

with javascript_semantics

for n=6 to 7 do

Line 2,022:

pp(s,{pp_Nest,1})

end for

===strings===

with javascript_semantics

for n=6 to 7 do

Line 2,035:

printf(1,"%s\n\n",{join(s,"\n")})

end for

<pre>

Line 2,058:

Based on [[2048#Phix]], and uses the same colour and font choices.

You can run this online [http://phix.x10.mx/p2js/strange_identity_matrices.htm here].

with javascript_semantics

include pGUI.e

Line 2,188:

IupClose()

end if

=={{header|PHP}}==

<~~lang~~ php><?php

<syntaxhighlight lang="php"><?php

$n = 9; // the number of rows

Line 2,201:

echo "\n";

}

</syntaxhighlight>

</lang>

<pre> 1 0 0 0 0 0 0 0 1

Line 2,215:

=={{header|Processing}}==

<~~lang~~ java>

//Aamrun, 27th June 2022

Line 2,235:

}

</syntaxhighlight>

</lang>

=={{header|Python}}==

===Pure Python===

<~~lang~~ python>'''Matrix with two diagonals'''

<syntaxhighlight lang="python">'''Matrix with two diagonals'''

Line 2,289:

# MAIN ---

if __name__ == '__main__':

main()</~~lang~~>

main()</syntaxhighlight>

<pre>1 0 0 0 0 0 1

Line 2,310:

===NumPy===

<~~lang~~ ~~Python~~>import numpy as np

<syntaxhighlight lang="python">import numpy as np

def diagdiag(n):

Line 2,329:

return a

print(diagdiag(7))</~~lang~~>

print(diagdiag(7))</syntaxhighlight>

<pre>

Line 2,343:

=={{header|Quackery}}==

<~~lang~~ ~~Quackery~~> [ [] swap dup times

<syntaxhighlight lang="quackery"> [ [] swap dup times

[ 0 over of

1 swap i poke

Line 2,357:

witheach

[ witheach [ echo sp ] cr ]

</syntaxhighlight>

</lang>

Line 2,382:

=={{header|Raku}}==

<lang ~~perl6~~>sub dual-diagonal($n) { ([1, |(0 xx $n-1)], *.rotate(-1) … *[*-1]).map: { [$_ Z|| .reverse] } }

<syntaxhighlight lang="raku" line>sub dual-diagonal($n) { ([1, |(0 xx $n-1)], *.rotate(-1) … *[*-1]).map: { [$_ Z|| .reverse] } }

.say for dual-diagonal(6);

say '';

.say for dual-diagonal(7);</~~lang~~>

.say for dual-diagonal(7);</syntaxhighlight>

<pre>[1 0 0 0 0 1]

Line 2,404:

=={{header|Red}}==

<~~lang~~ rebol>Red[]

<syntaxhighlight lang="rebol">Red[]

x-matrix: function [size][

Line 2,418:

x-matrix 6

prin newline

x-matrix 7</~~lang~~>

x-matrix 7</syntaxhighlight>

<pre>

Line 2,438:

=={{header|Ring}}==

<~~lang~~ ring>

# Project : Identity Matrix

# Date : 2022/16/02

Line 2,505:

score = 0

</syntaxhighlight>

</lang>

Outpu image:

Line 2,511:

=={{header|Sidef}}==

<~~lang~~ ruby>func dual_diagonal(n) {

<syntaxhighlight lang="ruby">func dual_diagonal(n) {

n.of {|k|

var r = (k.of(0) + [1] + (n - k - 1).of(0))

Line 2,519:

dual_diagonal(5).each{.join(' ').say}; say ''

dual_diagonal(6).each{.join(' ').say}</~~lang~~>

dual_diagonal(6).each{.join(' ').say}</syntaxhighlight>

<pre>

Line 2,538:

=={{header|Vlang}}==

<~~lang~~ vlang>fn special_matrix(n int) {

<syntaxhighlight lang="vlang">fn special_matrix(n int) {

for i in 0..n {

for j in 0..n {

Line 2,555:

println('')

special_matrix(5) // odd n

}</~~lang~~>

}</syntaxhighlight>

<pre>

Line 2,573:

=={{header|Wren}}==

A terminal based solution as I don't like asking people to view external images.

<~~lang~~ ecmascript>var specialMatrix = Fn.new { |n|

<syntaxhighlight lang="ecmascript">var specialMatrix = Fn.new { |n|

for (i in 0...n) {

for (j in 0...n) {

Line 2,584:

specialMatrix.call(6) // even n

System.print()

specialMatrix.call(7) // odd n</~~lang~~>

specialMatrix.call(7) // odd n</syntaxhighlight>

Line 2,605:

=={{header|XPL0}}==

<~~lang~~ ~~XPL0~~>proc DrawMat(S);

<syntaxhighlight lang="xpl0">proc DrawMat(S);

int S, I, J;

[for I:= 0 to S-1 do

Line 2,615:

[DrawMat(6); CrLf(0);

DrawMat(7); CrLf(0);

]</~~lang~~>

]</syntaxhighlight>