Des DLL pour Panoramic ?

const CR = chr(13)

dim mat$

mat =       " 2  1   5 -8   0" + CR
mat = mat + " 7  6   2  2  17" + CR
mat = mat + "-1 -3 -10  4 -10" + CR
mat = mat + " 2  2   2  1   7"

' *******************************************************************
' Solution d'un systeme d'equations lineaires (methode de Gauss-Jordan)
' *********************************************************************

const CR = chr(13)

dim mat$

mat =       " 2  1   5 -8   0" + CR
mat = mat + " 7  6   2  2  17" + CR
mat = mat + "-1 -3 -10  4 -10" + CR
mat = mat + " 2  2   2  1   7"

' Lecture des donnees

dim row$(), elem$()
dim nrow%, ncol%, i%, j%, res%

nrow = split(mat, CR, row())
ncol = split(row(1), " ", elem())

dim a(nrow, ncol), det

for i = 1 to nrow
  ncol = split(row(i), " ", elem())
  for j = 1 to ncol
    a(i,j) = val(elem(j))
  next j
next i

print : print "Matrice du systeme" : print
for i = 1 to nrow
  for j = 1 to ncol
    print a(i,j),
  next j
  print
next i

res = gaussjordan(a(), det)

print : print "Matrice inverse et vecteur solution" : print
for i = 1 to nrow
  for j = 1 to ncol
    print using "####.####"; a(i,j);
  next j
  print
next i

print : print "Determinant : "; using "####.####"; det

end


function gaussjordan% (a(), det)
' ------------------------------------------------------------------
' Algorithme de Gauss-Jordan pour une matrice a(1..n, 1..m), m >= n
' ------------------------------------------------------------------
' En entree :
' la sous-matrice a(1..n, 1..n) contient les coefficients
' la sous-matrice a(1..n, (n+1)..m) contient le(s) vecteur(s) constant(s)
'
' En sortie :
' la sous-matrice a(1..n, 1..n) contient la matrice inverse
' la sous-matrice a(1..n, (n+1)..m) contient le(s) vecteur(s) solution(s)
' le determinant de la matrice originelle est retourne dans det
' la fonction retourne un code d'erreur :
'  0 : pas d'erreur
' -1 : dimensions incompatibles (n > m)
' -2 : matrice quasi-singuliere
' ------------------------------------------------------------------

  const EPS = 1.0E-15

  dim n%, m%      ' Bornes de a
  dim i%, j%, k%  ' Indices de boucles
  dim ik%, jk%    ' Coordonnees du pivot
  dim pvt         ' Pivot
  dim t           ' Variable auxiliaire

  n = ubound(a, 1)
  m = ubound(a, 2)

  if n > m then return -1

  dim prow(n)  ' Sauvegarde la ligne du pivot
  dim pcol(n)  ' Sauvegarde la colonne du pivot
  dim mcol(n)  ' Sauvegarde une colonne de la matrice

  det = 1
  k = 1

  while k <= n
    ' Recherche du plus grand pivot dans la sous-matrice a[k..n, k..n]
    pvt = a(k, k)
    ik = k
    jk = k
    for i = k to n
      for j = k to n
        if abs(a(i, j)) > abs(pvt) then
          pvt = a(i, j)
          ik = i
          jk = j
        end_if
      next j
    next i

    ' Pivot trop faible ==> matrice quasi-singuliere
    if abs(pvt) < EPS then det = 0 : return -2

    ' Sauver la position du pivot
    prow(k) = ik
    pcol(k) = jk

    ' Mettre a jour le determinant
    det = det * pvt
    if ik <> k then det = -det
    if jk <> k then det = -det

    ' Echanger la ligne courante (k) avec la ligne du pivot (ik)
    if ik <> k then
      for j = 1 to m
        swap a(k, j), a(ik, j)
      next j
    end_if

    ' Echanger la colonne courante (k) avec la colonne du pivot (jk)
    if jk <> k then
      for i = 1 to n
        swap a(i, k), a(i, jk)
      next i
    end_if

    ' Stocker la colonne k de a dans mcol et mettre cette colonne a 0
    for i = 1 to n
      if i <> k then
        mcol(i) = a(i, k)
        a(i, k) = 0
      else
        mcol(i) = 0
        a(i, k) = 1
      end_if
    next i

    ' Transformer la ligne du pivot
    for j = 1 to m
      a(k, j) = a(k, j) / pvt
    next j

    ' Transformer les autres lignes
    for i = 1 to n
      if i <> k then
        t = mcol(i)
        for j = 1 to m
          a(i, j) = a(i, j) - t * a(k, j)
        next j
      end_if
    next i

    k = k + 1
  end_while

  ' Echanger les lignes de la matrice globale
  for i = n to 1 step -1
    ik = pcol(i)
    if ik <> i then
      for j = 1 to m
        swap a(i, j), a(ik, j)
      next j
    end_if
  next i

  ' Echanger les colonnes de la matrice inverse
  for j = n to 1 step -1
    jk = prow(j)
    if jk <> j then
      for i = 1 to n
        swap a(i, j), a(i, jk)
      next i
    end_if
  next j

  return 0
end_function

type Matrix
    dim as double m( any , any )
    declare constructor ( )
    declare constructor ( byval x as uinteger , byval y as uinteger )
end type
 
constructor Matrix ( )
end constructor
 
constructor Matrix ( byval x as uinteger , byval y as uinteger )
    redim this.m( x - 1 , y - 1 )
end constructor
 
operator * ( byref a as Matrix , byref b as Matrix ) as Matrix
    dim as Matrix ret
    dim as uinteger i, j, k
    if ubound( a.m , 2 ) = ubound( b.m , 1 ) and ubound( a.m , 1 ) = ubound( b.m , 2 ) then
        redim ret.m( ubound( a.m , 1 ) , ubound( b.m , 2 ) )
        for i = 0 to ubound( a.m , 1 )
            for j = 0 to ubound( b.m , 2 )
                for k = 0 to ubound( b.m , 1 )
                    ret.m( i , j ) += a.m( i , k ) * b.m( k , j )
                next k
            next j
        next i
    end if
    return ret
end operator
'some garbage matrices for demonstration
dim as Matrix a = Matrix(4 , 2)
a.m(0 , 0) = 1 : a.m(0 , 1) = 0
a.m(1 , 0) = 0 : a.m(1 , 1) = 1
a.m(2 , 0) = 2 : a.m(2 , 1) = 3
a.m(3 , 0) = 0.75 : a.m(3 , 1) = -0.5
dim as Matrix b = Matrix( 2 , 4 )
b.m(0 , 0) = 3.1 : b.m(0 , 1) = 1.6 : b.m(0 , 2) = -99 : b.m (0, 3) = -8
b.m(1 , 0) = 2.7 : b.m(1 , 1) = 0.6 : b.m(1 , 2) = 0 : b.m(1,3) = 21
dim as Matrix c = a * b
print c.m(0, 0), c.m(0, 1), c.m(0, 2), c.m(0, 3)
print c.m(1, 0), c.m(1, 1), c.m(1, 2), c.m(1, 3)
print c.m(2, 0), c.m(2, 1), c.m(2, 2), c.m(2, 3)
print c.m(3, 0), c.m(3, 1), c.m(3, 2), c.m(3, 3)