Bonjour,


je ne connais pas Scilab mais
dans un langage moins évolué (qb64) et typé:

det# correspond à la fonction determinant.
Mais il ne sembre que pour calculer le déterminant récursivement , il est nécessaire de créer le mineur dans un tableau pour l'envoyer comme paramètre.
(c'est le rôle de mkarray)




' on ne travaille qu'avec des mat <=10*10
CONST Forme = " ####.####"
CONST nLen = 12
CONST nfrac = 4


DATA 3
DATA 1,2,3
DATA 4,5,6
DATA 7,8,10

DIM SHARED Max AS INTEGER

'$dynamic
DIM A(0, 0) AS DOUBLE
DIM B(0, 0) AS DOUBLE
'$static
DIM r AS DOUBLE


CLS
CALL Init(A())
CALL Visu(A())
r = det#(A())
PRINT r
END


FUNCTION det# (src() AS DOUBLE)
DIM n AS INTEGER, ret AS DOUBLE
DIM i AS INTEGER, j AS INTEGER, s AS INTEGER, d AS DOUBLE, f AS STRING
f = ""
n = UBOUND(src)
IF n = 1 THEN
    ret = src(1, 1)
ELSE
    DIM B(n - 1, n - 1) AS DOUBLE
    ret = 0
    s = -1
    FOR i = 1 TO n
        CALL MkArray(B(), src(), i, 1)
        s = -s
        d = det#(B())
        ret = ret + src(i, 1) * s * d
    NEXT i
END IF
det# = ret
END FUNCTION


SUB MkArray (des() AS DOUBLE, src() AS DOUBLE, l AS INTEGER, c AS INTEGER)
DIM n AS INTEGER, i AS INTEGER, j AS INTEGER, k1 AS INTEGER, k2 AS INTEGER
n = UBOUND(src)
REDIM des(n - 1, n - 1) AS DOUBLE
k1 = 0
FOR i = 1 TO n
    IF i <> l THEN
        k1 = k1 + 1
        k2 = 0
        FOR j = 1 TO n
            IF j <> c THEN
                k2 = k2 + 1
                des(k1, k2) = src(i, j)
            END IF
        NEXT j
    END IF
NEXT i
END SUB



SUB Init (T() AS DOUBLE)
SHARED Max AS INTEGER
RESTORE
READ Max
REDIM T(Max, Max) AS DOUBLE
DIM i AS INTEGER, j AS INTEGER
FOR i = 1 TO Max
    FOR j = 1 TO Max
        READ T(i, j)
    NEXT j
NEXT i
END SUB


SUB Visu (T() AS DOUBLE)
SHARED Max AS INTEGER
DIM i AS INTEGER, j AS INTEGER, f AS STRING, n AS INTEGER
n = UBOUND(T)
f = SPACE$(nLen) + "|": FOR i = 1 TO n: f = f + NetStr$(i, nLen, nfrac) + "|": NEXT i: f = f + CHR$(13)
FOR i = 0 TO n: f = f + STRING$(nLen, "-") + "|": NEXT i: f = f + CHR$(13)
FOR i = 1 TO n: f = f + NetStr$(i, nLen, nfrac) + "|": FOR j = 1 TO n: f = f + NetStr$(T(i, j), nLen, nfrac) + "|": NEXT j: f = f + CHR$(13): NEXT i
FOR i = 0 TO n: f = f + STRING$(nLen, "-") + "|": NEXT i: f = f + CHR$(13)
PRINT f
END SUB




FUNCTION NetStr$ (N, ns, d)
NetStr$ = RIGHT$(SPACE$(ns) + STR$((CLNG(10 ^ d * N)) / 10 ^ d), ns)
END FUNCTION

Lire
il me semble que

Tout d'abord merci pour votre réponse.

Toutefois en Scilab, en théorie, cela ne prend qu'une ou deux lignes ... :/

J'avais posté le prog en basic en guise d'algorithme sans prétention.

Ceci peut vous aider dans votre traduction en Scilab,


en Haskell voici ce que cela donne:

- ................ --
import Data.List

type Vector = [Int]
type Matrix = [[Int]]

numRows :: Matrix -> Int
numRows = length
numColumns :: Matrix -> Int
numColumns = length . head

cut :: [a] -> Int -> [a]
cut [ ] n = [ ]
cut xs n | n < 1 || n > (length xs) = xs | otherwise = (take (n-1) xs) ++ drop n xs


--Now we use cut to remove the i th row and the j th entry of each column: --

remove :: Matrix -> Int -> Int -> Matrix
remove m i j | m == [ ] || i < 1 || i > numRows m || j < 1 || j > numColumns m = error "remove: (i,j) out of range" | otherwise = transpose ( cut (transpose ( cut m i ) ) j )

-- transpose :: [[a]] -> [[a]] --

determinant :: Matrix -> Int
determinant [ ] = error "determinant: 0-by-0 matrix"
determinant [[n]] = n
determinant m = sum [ (-1)^ (j+1) * (head m)!!(j-1) * determinant (remove m 1 j) | j <- [1..(numColumns m) ] ]
-- ......... --
-- se lance comme ceci --

determinant [[1,2,3],[4,5,6],[7,8,10]]


@+ Michel