Svenska ElektronikForumet

Al_Bundy skrev:En fråga! Om jag ska kopiera värden från en matris till en annan, då skriver jag denna kod.
...
Där eye(n) retunerar en identitetsmatris. Måste jag radera denna eye(n) efter jag har "kört klart" copyval(matrix* a, matrix* b) ? Eller beror det på vilken kompilator jag använder? Just nu är det C11.

AndLi skrev:Vad har du för nytta av att multiplicera tre oinitierade matriser?

mankan skrev:I C kan man göra:

Kod: Markera allt

matrix* x;
matrix* y;
matrix* z = multiply(y = set_scalar(3, create(1,3)), x = create(1,3), create(3,3));

Och då har du inte slavat bort något minne förutsatt du kör destroy() på dem senare.
Personligen tycker jag det är otydlig kod att ha tilldelningar inuti uttryck.

Sedan är ju detta kanske inte det bästa exemplet som AndLi påpekar såvida man inte kan initialisera matris x men koden blir ju ännu grötigare då.

void freeMatrix(matrix* m) {
	if (m != NULL) {
		if (m->data != NULL) {
			free(m->data);
			m->data = NULL;
		}

		free(m);
		m = NULL;
	}
}

Shimonu skrev:I C går det rätt bra att dölja att man jobbar med pekare och kan ha upplevelsen av att man jobbar med objekt.

Matrix_Example.c

Kod: Markera allt

#include "Matrix_Example.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

Matrix_Element GetMatrixElement(Matrix SourceMatrix, uint32_t Row, uint32_t Column)
{
    return SourceMatrix->MatrixPosition[Row][Column];
}

Matrix EmptyMatrix(uint32_t Rows, uint32_t Columns)
{
    uint32_t Row;
    Matrix_Element **NewMatrixArray = 
        (Matrix_Element **) malloc(sizeof(Matrix_Element *) * Rows);
    
    for(Row = 0; Row < Columns; Row++)
    {
        NewMatrixArray[Row] = (Matrix_Element *) malloc(sizeof(Matrix_Element) * Columns);
    }
    
    Matrix NewMatrix = (Matrix) malloc(sizeof(Matrix_Type));
    
    NewMatrix->MatrixPosition = NewMatrixArray;
    NewMatrix->Rows = Rows;
    NewMatrix->Columns = Columns;
    
    return NewMatrix;
}

Matrix IdentityMatrix(uint32_t Rows, uint32_t Columns)
{
    Matrix NewMatrix = EmptyMatrix(Rows, Columns);

    uint32_t Row_Index;
    uint32_t Column_Index;

    for(Row_Index = 0; Row_Index < Rows; Row_Index++)
    {
        for(Column_Index = 0; Column_Index < Columns; Column_Index++)
        {
            if(Row_Index == Column_Index)
            {
                NewMatrix->MatrixPosition[Row_Index][Column_Index] = 1.0f;
            }
        }
    }

    return NewMatrix;
}

void PrintMatrix(Matrix MatrixToPrint)
{
    uint32_t Row_Index;
    uint32_t Column_Index;
    
    for(Row_Index = 0; Row_Index < MatrixToPrint->Rows; Row_Index++)
    {
        for(Column_Index = 0; Column_Index < MatrixToPrint->Columns; Column_Index++)
        {
            printf("%0.3f ", GetMatrixElement(MatrixToPrint, Row_Index, Column_Index));
        }
        printf("\n");
    }
    printf("\n");
}

int main()
{
    Matrix My_Matrix = IdentityMatrix(36, 36);
    
    PrintMatrix(My_Matrix);
    
    return 0;
}

Matrix_Example.h

Kod: Markera allt

#include "stdint.h"

typedef float Matrix_Element;

typedef struct
{
    Matrix_Element** MatrixPosition;
    uint32_t        Rows;
    uint32_t        Columns;
} Matrix_Type;

typedef Matrix_Type *Matrix;

Jag kommer inte ihåg hur det är nu med C++ och överlagring. Skulle man kunna få till en överlagrad operator som gör att man kan ha matrismultiplikation av stilen A * B * C? Jag ser inte vad hindret skulle vara.

void printMatrix(matrix* m) {
	float* ptr = m->data;
	for (int i = 0; i < m->row; i++) {
		for (int j = 0; j < m->column; j++) {
			printf(" %9.6f", *(ptr++));
		}
		printf("\n");
	}
}

    uint32_t Row;
    for(Row = 0; Row < Columns; Row++)
    {
        NewMatrixArray[Row] = (Matrix_Element *) malloc(sizeof(Matrix_Element) * Columns);
    }

Al_Bundy skrev:

AndLi skrev:Vad har du för nytta av att multiplicera tre oinitierade matriser?

Vektorisering.

Al_Bundy skrev:
Jag har gjort liknande, men vad mycket C-kod du skrev för just detta

Min print ser ut så här.

Kod: Markera allt

void printMatrix(matrix* m) {
	float* ptr = m->data;
	for (int i = 0; i < m->row; i++) {
		for (int j = 0; j < m->column; j++) {
			printf(" %9.6f", *(ptr++));
		}
		printf("\n");
	}
}

Al_Bundy skrev: Varför deklarerade du uint32_t utanför forloopen?

Kod: Markera allt

    uint32_t Row;
    for(Row = 0; Row < Columns; Row++)
    {
        NewMatrixArray[Row] = (Matrix_Element *) malloc(sizeof(Matrix_Element) * Columns);
    }

mankan skrev:Det är hög tid att du lär dig hur stack och heap fungerar oavsett programspråk.