Matrisberäkningar med för STM32?

Al_Bundy · Inlägg av **Al_Bundy** » 6 februari 2019, 23:12:39

Då är det allsnå säkert att använda detta på uC?

Nu har jag kompilerat klart CLapack. Jag använde mig av standard Blas.
Jag fick fram en fil. Nu ska man bara komma på ett bra sätt och länka denna .a fil.

Ingen som vet?

Markering_049.png

Markering_050.png

Edit: Nu har jag fått det att fungera.

GNU Octave

Kod: Markera allt

>> B = rand(15,15)
B =

     0.84245     0.23405     0.69751     0.27905     0.18851     0.61018     0.62182     0.71839     0.79161     0.56156     0.83395    0.092388      0.8511     0.44826     0.82158
     0.84614     0.15947    0.096336     0.80793     0.35114     0.42583      0.2134     0.75324     0.31391     0.22892     0.94773     0.81204     0.62554     0.28367     0.26637
     0.26509     0.91429     0.14222     0.28321     0.11607     0.41188     0.10071     0.18224     0.75723     0.89125     0.62494     0.83016     0.46448     0.73119     0.10982
     0.45197     0.44562     0.27909     0.76019    0.014571     0.42705     0.70214     0.64936     0.98451     0.59632     0.07654     0.95633     0.18574     0.92716     0.65401
     0.48034     0.38327     0.32906     0.34794     0.68673     0.54113     0.34142     0.48561     0.37221     0.16097     0.15569     0.63287     0.17518    0.055447     0.44536
     0.54119     0.34478     0.53297      0.2796     0.95212      0.5353      0.8202     0.32707   0.0062771     0.64993    0.057361     0.59959     0.16867     0.67892     0.52882
    0.082573     0.96676    0.080315     0.48813     0.33496      0.4436     0.01436     0.89664     0.49167     0.37092     0.31586     0.54683     0.65159     0.38531     0.20697
     0.35775     0.42437     0.79392     0.49724     0.01319   0.0074932     0.66462      0.6506      0.9889     0.27213     0.99607     0.68418     0.70238     0.81493     0.46062
     0.22609     0.59924     0.74631     0.81566     0.92784     0.47376     0.83531     0.47031     0.97093     0.44778     0.42997     0.71882     0.36504     0.34216     0.95187
     0.87475     0.22003     0.71901     0.90968     0.27265     0.16106     0.21283     0.14918     0.16776     0.83038     0.43605     0.85075     0.54771     0.77479     0.24739
     0.21203     0.65616     0.63534     0.57569     0.22113     0.48063     0.24207     0.54873     0.25042     0.82671     0.88986     0.41674     0.95235     0.89875     0.15004
     0.86164     0.89058     0.66423     0.60958     0.47708     0.18674     0.66359     0.92383     0.48073     0.79466     0.64519     0.69876   0.0066587     0.55114     0.10979
     0.35586     0.94772     0.28888     0.63119     0.42774     0.82597     0.90274     0.40152     0.96414     0.84376    0.028355    0.040771     0.85359     0.92875     0.32352
     0.39274     0.27788     0.41549     0.90884    0.042767     0.64168    0.086933     0.47941     0.91491     0.26425     0.11667     0.49996     0.12644     0.87136     0.30768
     0.86527     0.92393     0.47957     0.32175     0.87965     0.13719      0.4014     0.25277     0.83936     0.73476     0.97174     0.65243     0.85813     0.62705   0.0013063

>> tic; [u,s,v] = svd(B); toc
Elapsed time is 0.000423908 seconds.
>> s
s =

Diagonal Matrix

      7.8389           0           0           0           0           0           0           0           0           0           0           0           0           0           0
           0      1.7935           0           0           0           0           0           0           0           0           0           0           0           0           0
           0           0      1.6371           0           0           0           0           0           0           0           0           0           0           0           0
           0           0           0      1.5177           0           0           0           0           0           0           0           0           0           0           0
           0           0           0           0      1.4298           0           0           0           0           0           0           0           0           0           0
           0           0           0           0           0      1.2674           0           0           0           0           0           0           0           0           0
           0           0           0           0           0           0         1.1           0           0           0           0           0           0           0           0
           0           0           0           0           0           0           0     0.90737           0           0           0           0           0           0           0
           0           0           0           0           0           0           0           0     0.84691           0           0           0           0           0           0
           0           0           0           0           0           0           0           0           0     0.67887           0           0           0           0           0
           0           0           0           0           0           0           0           0           0           0     0.56789           0           0           0           0
           0           0           0           0           0           0           0           0           0           0           0     0.46979           0           0           0
           0           0           0           0           0           0           0           0           0           0           0           0     0.39255           0           0
           0           0           0           0           0           0           0           0           0           0           0           0           0     0.19035           0
           0           0           0           0           0           0           0           0           0           0           0           0           0           0    0.043839

>>

Bra tid!

Nu är det Clapack!

Kod: Markera allt

/*
 ============================================================================
 Name        : BlasTest.c
 Author      : 
 Version     :
 Copyright   : MIT
 Description : Hello World in C, Ansi-style
 ============================================================================
 */

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include "blaswrap.h"
#include "f2c.h"
#include "clapack.h"


#define SIZE 15

void MAIN_(){}
void MAIN__(){}
void _MAIN_(){}

int main( )
{

	clock_t start, end;
		float cpu_time_used;

		start = clock();

     char JOBU;
     char JOBVT;

     int i;

     integer M = SIZE;
     integer N = SIZE;

     integer LDA = M;
     integer LDU = M;
     integer LDVT = N;
     integer LWORK;
     integer INFO;

     integer mn = min( M, N );

     integer MN = max( M, N );

     double a[SIZE*SIZE] = {
    		 0.84245,     0.23405   ,  0.69751 ,    0.27905   ,  0.18851  ,   0.61018    , 0.62182  ,   0.71839   ,  0.79161     ,0.56156   ,  0.83395   , 0.092388     , 0.8511    , 0.44826    , 0.82158,
    		     0.84614  ,   0.15947  ,  0.096336  ,   0.80793  ,   0.35114 ,    0.42583 ,     0.2134 ,    0.75324   ,  0.31391 ,    0.22892  ,   0.94773 ,    0.81204   ,  0.62554 ,    0.28367   ,  0.26637,
    		     0.26509  ,   0.91429  ,   0.14222  ,   0.28321   ,  0.11607 ,    0.41188 ,    0.10071 ,    0.18224   ,  0.75723 ,    0.89125  ,   0.62494 ,    0.83016   ,  0.46448  ,   0.73119  ,   0.10982,
    		     0.45197  ,   0.44562  ,   0.27909  ,   0.76019   , 0.014571 ,    0.42705 ,    0.70214 ,    0.64936   ,  0.98451 ,    0.59632  ,   0.07654 ,    0.95633   ,  0.18574   ,  0.92716  ,   0.65401,
    		     0.48034  ,   0.38327  ,   0.32906  ,   0.34794   ,  0.68673 ,    0.54113 ,    0.34142 ,    0.48561  ,   0.37221 ,    0.16097  ,   0.15569 ,    0.63287  ,   0.17518  ,  0.055447  ,   0.44536,
    		     0.54119  ,   0.34478   ,  0.53297  ,    0.2796   ,  0.95212 ,     0.5353 ,     0.8202 ,    0.32707  , 0.0062771 ,    0.64993  ,  0.057361 ,    0.59959  ,   0.16867  ,   0.67892  ,   0.52882,
    		    0.082573  ,   0.96676  ,  0.080315  ,   0.48813   ,  0.33496 ,     0.4436 ,    0.01436 ,    0.89664   ,  0.49167 ,    0.37092  ,   0.31586 ,    0.54683  ,   0.65159  ,   0.38531  ,   0.20697,
    		     0.35775  ,   0.42437  ,   0.79392  ,   0.49724    , 0.01319 ,  0.0074932 ,    0.66462 ,     0.6506   ,   0.9889 ,    0.27213  ,   0.99607 ,    0.68418  ,   0.70238  ,   0.81493  ,   0.46062,
    		     0.22609  ,   0.59924  ,   0.74631  ,   0.81566   ,  0.92784 ,    0.47376 ,    0.83531 ,    0.47031   ,  0.97093 ,    0.44778  ,   0.42997 ,    0.71882  ,   0.36504  ,   0.34216  ,   0.95187,
    		     0.87475  ,   0.22003  ,   0.71901  ,   0.90968   ,  0.27265 ,    0.16106 ,    0.21283 ,    0.14918   ,  0.16776 ,    0.83038  ,   0.43605 ,    0.85075  ,   0.54771  ,   0.77479  ,   0.24739,
    		     0.21203  ,   0.65616  ,   0.63534  ,   0.57569   ,  0.22113 ,    0.48063 ,    0.24207 ,    0.54873   ,  0.25042 ,    0.82671  ,   0.88986 ,    0.41674  ,   0.95235  ,   0.89875  ,   0.15004,
    		     0.86164  ,   0.89058  ,   0.66423  ,   0.60958   ,  0.47708 ,    0.18674 ,    0.66359 ,    0.92383  ,   0.48073 ,    0.79466  ,   0.64519 ,    0.69876  , 0.0066587  ,   0.55114  ,   0.10979,
    		     0.35586  ,   0.94772  ,   0.28888  ,   0.63119   ,  0.42774 ,    0.82597 ,    0.90274 ,    0.40152  ,   0.96414 ,    0.84376  ,  0.028355 ,   0.040771   ,  0.85359  ,   0.92875  ,   0.32352,
    		     0.39274  ,   0.27788  ,   0.41549  ,   0.90884  ,  0.042767 ,    0.64168 ,   0.086933 ,    0.47941  ,   0.91491 ,    0.26425  ,   0.11667 ,    0.49996   ,  0.12644  ,   0.87136  ,   0.30768,
    		     0.86527 ,    0.92393  ,   0.47957  ,   0.32175  ,   0.87965 ,    0.13719 ,     0.4014 ,    0.25277  ,   0.83936 ,    0.73476  ,   0.97174 ,    0.65243   ,  0.85813  ,   0.62705  , 0.0013063};




     double s[SIZE];
     double wk[201];
     double uu[SIZE*SIZE];
     double vt[SIZE*SIZE];

       JOBU = 'A';

       JOBVT = 'A';

    LWORK =  201;


    dgesvd_( &JOBU, &JOBVT, &M, &N, a, &LDA, s, uu,
          &LDU, vt, &LDVT, wk, &LWORK, &INFO);

    printf("\n INFO=%d", INFO );

    for ( i= 0; i< SIZE; i++ ) {
        printf("\n s[ %d ] = %f", i, s[ i ] );
    }

    end = clock();
    	cpu_time_used = ((float) (end - start)) / CLOCKS_PER_SEC;
    	printf("\nTotal speed  was %f,", cpu_time_used);

    return 0;
}

Resultat

INFO=0
s[ 0 ] = 7.838945
s[ 1 ] = 1.793532
s[ 2 ] = 1.637058
s[ 3 ] = 1.517732
s[ 4 ] = 1.429764
s[ 5 ] = 1.267348
s[ 6 ] = 1.099945
s[ 7 ] = 0.907375
s[ 8 ] = 0.846915
s[ 9 ] = 0.678870
s[ 10 ] = 0.567895
s[ 11 ] = 0.469790
s[ 12 ] = 0.392545
s[ 13 ] = 0.190355
s[ 14 ] = 0.043838
Total speed was 0.000433,

Ja! Helt nöjd, trots att GNU Octave var snabbare med 0.000009092 sekunder, men knappt märkbart. Nu mätte jag över hela C-koden till skillnad från GNU Octave där jag bara mätte över SVD-funktionen. Så vi kan säga att C vann slaget!

Jag använder versionen av BLAS som är den "generella" versionen, dvs ej anpassad efter någon specifik CPU. Denna BLAS version finns inkluderad i Clapack.

Då har jag vissa steg att göra:
1. Lär mig biblioteket. Det verkar vara rätt röriga funktioner.
2. Få kompilatorn att tolka double som float
3. Skriv till STM32

hawkan · Inlägg av **hawkan** » 7 februari 2019, 07:01:09

Det finns väl en version för single precision? Då slipper du 2.

Shimonu · Inlägg av **Shimonu** » 7 februari 2019, 08:20:05

Du pratar goja när det kommer till double och float. Att få kompilatorn att tolka double som float, vad betyder det? Antingen kör du double eller så kör du float, det finns inget som kompilatorn ska tolka. Möjligen vill du se om du kan utnyttja FPUn för beräkning med double men annars kommer det användas mjukvarualgoritmer för att göra beräkningar med double.

Al_Bundy · Inlägg av **Al_Bundy** » 7 februari 2019, 09:11:43

Shimonu skrev:Du pratar goja när det kommer till double och float. Att få kompilatorn att tolka double som float, vad betyder det? Antingen kör du double eller så kör du float, det finns inget som kompilatorn ska tolka. Möjligen vill du se om du kan utnyttja FPUn för beräkning med double men annars kommer det användas mjukvarualgoritmer för att göra beräkningar med double.

Är det någon flagga man måste ange? Eller är det bara att skriva kompilera och se glad ut? Typ som att tanka bilen.

hawkan skrev:Det finns väl en version för single precision? Då slipper du 2.

Har ingen aning. Inte vad jag ser.

hawkan · Inlägg av **hawkan** » 7 februari 2019, 11:52:40

Kolla om detta ger vad du vill

Kod: Markera allt

III.  Each 'make' may be accomplished just for one or a subset of the 
     precisions desired.  For example:
	make single
	make single complex
	make single double complex complex16
     Using make without any arguments will compile all four precisions.

från https://www.netlib.org/clapack/readme.install om det var därifrån det kom.
Single precision == float.
Double precision == double.

Al_Bundy · Inlägg av **Al_Bundy** » 7 februari 2019, 14:58:40

Opedagogiskt!

Link with BLAS which Fortran calling interface

Jag tolkar det som att man kör Fortran istället för C.

Hur ska man tolka I, II och III?

Kod: Markera allt

(5) Build the archive containing lapack source code by doing:
      cd CLAPACK/SRC; make

(6) Compile the matrix generation software, the eigenroutine TESTING
    code, the linear system TESTING code, and run the LAPACK tests 
    by doing:
      cd CLAPACK/TESTING/MATGEN; make
      cd CLAPACK/TESTING; make

    Inspect the output files *.out to confirm that no errors occurred.

I.   Compile the matrix generation software, the eigenroutine TESTING code,
     the linear system TESTING code, and run the LAPACK tests separately
     by doing:
	cd CLAPACK/TESTING/MATGEN; make
	cd CLAPACK/TESTING/EIG; make
	cd CLAPACK/TESTING/LIN; make
	cd CLAPACK/TESTING; make
II. After the executable files and libraries have been created for each
     of the compiles, the object files should be removed by doing:
	make clean
III.  Each 'make' may be accomplished just for one or a subset of the 
     precisions desired.  For example:
	make single
	make single complex
	make single double complex complex16
     Using make without any arguments will compile all four precisions.

Al_Bundy · Inlägg av **Al_Bundy** » 7 februari 2019, 21:35:28

Är det någon här som hittar manualen till Clapack? Jag hittar den inte.

sodjan · Inlägg av **sodjan** » 7 februari 2019, 21:49:24

>> Link with BLAS which Fortran calling interface

> Jag tolkar det som att man kör Fortran istället för C.

Det är ingen självklar tolkning rent generellt. Man kan använda ett
"calling interface" från ett visst språk i ett annat språk. Men visst,
jag ser inte varför man skulle välja att följa just Fortrans interface
om rutinerna inte också är skrivna i Fortran.

Men, det är ju enbart ett problem om man själv ska kompilera om
rutinerna, annars är det ju bara att köra, spelar ingen praktiskt roll
vad det är skrivit i, bara man följer det "calling interface" som används.
Och förutsatt att det finns byggt för den plattform man använder...

Al_Bundy · Inlägg av **Al_Bundy** » 7 februari 2019, 21:59:58

I detta fall ska jag använda den BLAS-version som följer med CLAPACK. Den ska tydligen inte vara beroende på vilken plattform man kör på. Jag har inte angett någon CPU t.ex ARM, AMD, Intel eller liknande.

Shimonu · Inlägg av **Shimonu** » 7 februari 2019, 22:01:09

Det är inte CPUer du listar där heller utan tillverkare

Al_Bundy · Inlägg av **Al_Bundy** » 7 februari 2019, 22:25:04

Ja, men ni förstår säkert.

Annars hittar jag "dokumentationen", men den är för FORTRAN. Hur ska man tolka detta?
http://www.netlib.org/lapack/explore-ht ... 4713ce02f2

Kod: Markera allt

dgesvd 	( 	character  	JOBU,
		character  	JOBVT,
		integer  	M,
		integer  	N,
		double precision, dimension( lda, * )  	A,
		integer  	LDA,
		double precision, dimension( * )  	S,
		double precision, dimension( ldu, * )  	U,
		integer  	LDU,
		double precision, dimension( ldvt, * )  	VT,
		integer  	LDVT,
		double precision, dimension( * )  	WORK,
		integer  	LWORK,
		integer  	INFO 
	)

För C så är det så här. Notera att dgsvd heter dgsvd_ i C. Varför? Dålig manual!!

Kod: Markera allt

char JOBU;
     char JOBVT;

     int i;

     integer M = SIZE;
     integer N = SIZE;

     integer LDA = M;
     integer LDU = M;
     integer LDVT = N;
     integer LWORK;
     integer INFO;

     integer mn = min( M, N );

     integer MN = max( M, N );

     double a[SIZE*SIZE] = {
    		 0.84245,     0.23405   ,  0.69751 ,    0.27905   ,  0.18851  ,   0.61018    , 0.62182  ,   0.71839   ,  0.79161     ,0.56156   ,  0.83395   , 0.092388     , 0.8511    , 0.44826    , 0.82158,
    		     0.84614  ,   0.15947  ,  0.096336  ,   0.80793  ,   0.35114 ,    0.42583 ,     0.2134 ,    0.75324   ,  0.31391 ,    0.22892  ,   0.94773 ,    0.81204   ,  0.62554 ,    0.28367   ,  0.26637,
    		     0.26509  ,   0.91429  ,   0.14222  ,   0.28321   ,  0.11607 ,    0.41188 ,    0.10071 ,    0.18224   ,  0.75723 ,    0.89125  ,   0.62494 ,    0.83016   ,  0.46448  ,   0.73119  ,   0.10982,
    		     0.45197  ,   0.44562  ,   0.27909  ,   0.76019   , 0.014571 ,    0.42705 ,    0.70214 ,    0.64936   ,  0.98451 ,    0.59632  ,   0.07654 ,    0.95633   ,  0.18574   ,  0.92716  ,   0.65401,
    		     0.48034  ,   0.38327  ,   0.32906  ,   0.34794   ,  0.68673 ,    0.54113 ,    0.34142 ,    0.48561  ,   0.37221 ,    0.16097  ,   0.15569 ,    0.63287  ,   0.17518  ,  0.055447  ,   0.44536,
    		     0.54119  ,   0.34478   ,  0.53297  ,    0.2796   ,  0.95212 ,     0.5353 ,     0.8202 ,    0.32707  , 0.0062771 ,    0.64993  ,  0.057361 ,    0.59959  ,   0.16867  ,   0.67892  ,   0.52882,
    		    0.082573  ,   0.96676  ,  0.080315  ,   0.48813   ,  0.33496 ,     0.4436 ,    0.01436 ,    0.89664   ,  0.49167 ,    0.37092  ,   0.31586 ,    0.54683  ,   0.65159  ,   0.38531  ,   0.20697,
    		     0.35775  ,   0.42437  ,   0.79392  ,   0.49724    , 0.01319 ,  0.0074932 ,    0.66462 ,     0.6506   ,   0.9889 ,    0.27213  ,   0.99607 ,    0.68418  ,   0.70238  ,   0.81493  ,   0.46062,
    		     0.22609  ,   0.59924  ,   0.74631  ,   0.81566   ,  0.92784 ,    0.47376 ,    0.83531 ,    0.47031   ,  0.97093 ,    0.44778  ,   0.42997 ,    0.71882  ,   0.36504  ,   0.34216  ,   0.95187,
    		     0.87475  ,   0.22003  ,   0.71901  ,   0.90968   ,  0.27265 ,    0.16106 ,    0.21283 ,    0.14918   ,  0.16776 ,    0.83038  ,   0.43605 ,    0.85075  ,   0.54771  ,   0.77479  ,   0.24739,
    		     0.21203  ,   0.65616  ,   0.63534  ,   0.57569   ,  0.22113 ,    0.48063 ,    0.24207 ,    0.54873   ,  0.25042 ,    0.82671  ,   0.88986 ,    0.41674  ,   0.95235  ,   0.89875  ,   0.15004,
    		     0.86164  ,   0.89058  ,   0.66423  ,   0.60958   ,  0.47708 ,    0.18674 ,    0.66359 ,    0.92383  ,   0.48073 ,    0.79466  ,   0.64519 ,    0.69876  , 0.0066587  ,   0.55114  ,   0.10979,
    		     0.35586  ,   0.94772  ,   0.28888  ,   0.63119   ,  0.42774 ,    0.82597 ,    0.90274 ,    0.40152  ,   0.96414 ,    0.84376  ,  0.028355 ,   0.040771   ,  0.85359  ,   0.92875  ,   0.32352,
    		     0.39274  ,   0.27788  ,   0.41549  ,   0.90884  ,  0.042767 ,    0.64168 ,   0.086933 ,    0.47941  ,   0.91491 ,    0.26425  ,   0.11667 ,    0.49996   ,  0.12644  ,   0.87136  ,   0.30768,
    		     0.86527 ,    0.92393  ,   0.47957  ,   0.32175  ,   0.87965 ,    0.13719 ,     0.4014 ,    0.25277  ,   0.83936 ,    0.73476  ,   0.97174 ,    0.65243   ,  0.85813  ,   0.62705  , 0.0013063};




     double s[SIZE];
     double wk[201];
     double uu[SIZE*SIZE];
     double vt[SIZE*SIZE];

       JOBU = 'A';

       JOBVT = 'A';

    LWORK =  201;


    start = clock();
    dgesvd_( &JOBU, &JOBVT, &M, &N, a, &LDA, s, uu, &LDU, vt, &LDVT, wk, &LWORK, &INFO);

    end = clock();
        	cpu_time_used = ((float) (end - start)) / CLOCKS_PER_SEC;
        	printf("\nTotal speed  was %f,", cpu_time_used);

    printf("\n INFO=%d", INFO );

    for ( i= 0; i< SIZE; i++ ) {
        printf("\n s[ %d ] = %f", i, s[ i ] );
    }

hawkan · Inlägg av **hawkan** » 7 februari 2019, 22:48:55

Precis så ser det ut när man anropar en funktion skriven i fortran. Åtminstone på *x-system. Fortrans parametrar är alltid callbyreference och det läggs alltid på ett _ i funktionsnamnet för att inte kollidera med t ex c-funktioner. Uråldrigt naturligtvis.
Det var väl därför nån gjorde om den till C, så man slapp sånt där?
Hur långsamt gick det med den?

Kan du kompilera en version för stm32?

Al_Bundy · Inlägg av **Al_Bundy** » 7 februari 2019, 23:20:47

Jag har inte testat kompilera för STM32 och jag vet inte heller hur man gör. Jag har dock hört att det finns en BLAS version för ARM. OpenBLAS om man ska vara exakt.

Just nu försöker jag att lära mig biblioteket. Kanske man ska inkludera LAPACK i mitt bibliotek som ett "HAL"-bibliotek, bara för att göra det enkelt att använda LA-Pack!

Edit: Har hittat en bra dokumentation nu! Någon som vill hjälpa till att skapa några exampel? Vi använder förstås vanliga generella matriser.
http://www.netlib.org/lapack/explore-ht ... __g_e.html

Vi säger att jag ska lösa ekvationen:
\(AX=B\),
Där A och B är känd och jag vill hitta X. Ok nu kör vi! Som manualen säger så skall vi använda oss av FORTRAN's sgesv, men i C kallas den sgesv_
http://www.netlib.org/lapack/explore-ht ... 1a1fd28e78

Jag ska försöka lösa detta.

Kod: Markera allt

>> A = [3 4 2 5 5; 2 4 5 -5 5; -13 -4 5 5 3; -34 -4 -2 -5 -5; 2 4 5 -3 5]
A =

    3    4    2    5    5
    2    4    5   -5    5
  -13   -4    5    5    3
  -34   -4   -2   -5   -5
    2    4    5   -3    5

>> B = [6 2; 3 5; 1 -4; 5 1; 5 44]
B =

    6    2
    3    5
    1   -4
    5    1
    5   44

>> X = linsolve(A, B)
X =

   -0.354839   -0.096774
    2.854503   46.298387
    2.215054   65.967742
    1.000000   19.500000
   -2.756720  -82.467742

>>

Någon som vet vad jag gör för fel?

Kod: Markera allt

/*
 ============================================================================
 Name        : BlasTest.c
 Author      : 
 Version     :
 Copyright   : MIT
 Description : Hello World in C, Ansi-style
 ============================================================================
 */

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include "blaswrap.h"
#include "f2c.h"
#include "clapack.h"

int main( )
{

	clock_t start, end;
	float cpu_time_used;

	integer N = 5; // Vi har en 5 dimensions matris A
	integer NRHS = 2; // Vi har en 2 kolumns B matris
	integer LDA = 5; // Samma dimension som matris A
	real A[5*5] = {
			3,    4,    2,    5,    5,
		    2,    4,    5,   -5,    5,
		  -13,   -4,    5,    5,    3,
		  -34,   -4 ,  -2,   -5,   -5,
		    2,    4,    5,   -3,    5};

	integer IPIV[5] = {1,1,1,1,1}; // vi sätter denna som en diagonalmatris
	integer LDB = 5; // Raden på matris B
	real B[5*2] = {
			6,    2,
			3,    5,
			1,   -4,
			5,    1,
			5,   44,
	};

	integer INFO; // Inget vi behöver säga nu!


    start = clock();

    sgesv_(&N, &NRHS, A, &LDA, IPIV, B, &LDB, &INFO); // Arrayer behöver vi INTE använda &-tecknet på


    end = clock();
    cpu_time_used = ((float) (end - start)) / CLOCKS_PER_SEC;
    printf("\nTotal speed  was %f and INFO = %d\n", cpu_time_used, (int) INFO);

    // Enligt dokumentationen så om info = 0, så betyder det att B = X, dvs våran lösning på AX=B
    for(int i = 0; i < 5; i++){
    	for(int j = 0; j < 2; j++){
    		printf("%f ", B[i*4+j]);
    	}
    	printf("\n");
    }

    return 0;
}

Resultat:

Total speed was 0.004042 and INFO = 0
-0.911961 -6.604163
7.708328 16.578283
-0.900874 -81.770782
5.000000 1.000000
0.400000 -5.000000

Rick81 · Inlägg av **Rick81** » 8 februari 2019, 09:14:40

Nu hänger jag inte med riktigt: du har ju två C-varianter (din egen som du lagt ned ett antal timmar på och Armadillo) som fungerar med matris operationer i C och som båda ger korrekta svar jämfört med GNU octave.

Varför ger du dig på en tredje som du inte ens vet om den går kompilera till STM32 när du inte ens testat de andra två? Vore inte nästa logiska steg köra på STM32 och sedan börja testa matris operationer på riktig data?

Al_Bundy · Inlägg av **Al_Bundy** » 8 februari 2019, 09:26:38

För att Lapack är optimerat. Det var inte mitt. Sedan var det många som klagade på malloc = förbjudet.

Jag skrev också mitt C bibliotek för att komma igång med C. Hade inte riktigt kodat mycket i C förut.

Nu försöker jag lära mig Lapack, men det går bet.

Matrisberäkningar med för STM32?

Re: Matrisberäkningar med för STM32?

Re: Matrisberäkningar med för STM32?

Re: Matrisberäkningar med för STM32?

Re: Matrisberäkningar med för STM32?

Re: Matrisberäkningar med för STM32?

Re: Matrisberäkningar med för STM32?

Re: Matrisberäkningar med för STM32?

Re: Matrisberäkningar med för STM32?

Re: Matrisberäkningar med för STM32?

Re: Matrisberäkningar med för STM32?

Re: Matrisberäkningar med för STM32?

Re: Matrisberäkningar med för STM32?

Re: Matrisberäkningar med för STM32?

Re: Matrisberäkningar med för STM32?

Re: Matrisberäkningar med för STM32?