test.cpp

#include "stdafx.h"
#include <iostream>
#include <stdlib.h>
#include <time.h>

struct DataType {
	int value;
};

struct Vector {
	int size;
	DataType * data;
};

struct Matrix {
	int nrows;
	int ncols;
	Vector ** data;
};


Vector * create(int size) {
	Vector *ret = new Vector;
	ret->size = size;
	ret->data = new DataType[size];
	return ret;
}

Vector * clone(Vector * v) {
	Vector *x = new Vector;
	x = v;
	return x;
}

Vector * mult(Vector * v, DataType dt) {
	Vector *nw = new Vector;
	nw->size = v->size;
	nw->data = new DataType[nw->size];
	for (int i = 0; i < v->size; i++) {
		nw->data[i].value = dt.value * v->data[i].value;
	}
	return nw;
}

void destroy(Vector * v) {
	delete v;
}

void random(Vector * v) {
	for (int i = 0; i<v->size; i++) {
		v->data[i].value = rand() % 100;
	}
}

void print(Vector * v) {
	std::cout << "[" << v << "] Vector size = " << v->size << std::endl;
	for (int i = 0; i<v->size; i++) {
		std::cout << "DataType[" << i << "] = " << v->data[i].value << std::endl;
	}
	std::cout << std::endl;
}
/*
Vector * create(int size);
Vector * clone(Vector * v);
void destroy(Vector * v);
void random(Vector * v);
void print(Vector * v);

Matrix * create(int nrows, int ncols);
Matrix * clone(Matrix * m);
void print(Matrix * m);
void destroy(Matrix * m);
void random(Matrix * m);

Matrix * mult(Matrix * m1, Matrix * m2);
Matrix * mult(Matrix * m, Vector * v);
Matrix * mult(Matrix * m, DataType dt);
Vector * mult(Vector * v, DataType dt);

Matrix * plus(Matrix * m1, Matrix * m2);
*/

Matrix * create(int nrows, int ncols){
	Matrix * m = new Matrix;
	m->ncols = ncols;
	m->nrows = nrows;
	m->data = new Vector*[ncols];
	for (int i = 0; i<ncols; i++)
		m->data[i] = create(nrows);
	return m;
};

Matrix * clone(Matrix * m){
	Matrix * c = new Matrix;
	c->ncols = m->ncols;
	c->nrows = m->nrows;
	c->data = new Vector*[m->ncols];
	for (int i = 0; i<m->ncols; i++){
		c->data[i] = create(m->nrows);
		c->data[i] = clone(m->data[i]);
	}
	return c;
};

void print(Matrix * m){
	for (int z = 0; z < m->nrows; z++){
		for (int i = 0; i<m->ncols; i++)
			std::cout << m->data[z]->data[i].value << ' ';
		std::cout << std::endl;
	}
	std::cout << std::endl;
};

void destroy(Matrix * m){
	for (int i = 0; i < m->ncols; i++)
		destroy(m->data[i]);
	delete[] m->data;
	delete m;
};

void random(Matrix * m){
	for (int i = 0; i < m->ncols; i++)
		random(m->data[i]);
};

Matrix * mult(Matrix * m, DataType dt){
	Matrix * x = new Matrix;
	x->ncols = m->ncols;
	x->nrows = m->nrows;
	x->data = new Vector*[m->ncols];
	for (int i = 0; i < m->ncols; i++){
		x->data[i] = create(m->nrows);
		x->data[i] = mult(m->data[i], dt);
	}
	return x;
};

Matrix * mult(Matrix * m, Vector * v){
	DataType temp;
	Matrix * x = new Matrix;
	x->ncols = 1;
	x->nrows = m->nrows;
	x->data = new Vector*[m->ncols];
	for (int i = 0; i < x->ncols; i++){
		x->data[i] = create(m->nrows);
	}
	for (int i = 0; i < m->nrows; i++){
		x->data[i] = create(m->nrows);
	}
	return x;
};

Matrix * mult(Matrix * m1, Matrix * m2){
	if (m1->ncols == m2->nrows){
		DataType temp;
		Matrix * x = new Matrix;
		x->nrows = m1->nrows;
		x->ncols = m2->ncols;
		x->data = new Vector*[x->ncols];
		for (int i = 0; i<x->ncols; i++){
			x->data[i] = create(x->nrows);
		}
		for (int r = 0; r<x->nrows; r++){
			for (int c = 0; c<x->ncols; c++){
				temp.value = 0;
				for (int k = 0; k<x->ncols; k++)
					temp.value += m1->data[k]->data[r].value*m2->data[c]->data[k].value;
				x->data[c]->data[r] = temp;
			}
		}
		return x;
	}
	else
		return NULL;
};

int _tmain(int argc, _TCHAR* argv[])
{
	srand(time(NULL));
	DataType v = { 10 };
	/*
	DataType v;
	v.value = 10;
	*/

	Vector * v1 = create(10);
	random(v1);
	print(v1);


	Vector * v2 = mult(v1, v);
	print(v2);

	Matrix * m1 = create(10, 10);
	random(m1);
	print(m1);
	Matrix * m2 = clone(m1);
	print(m2);
	Matrix * mm = mult(m2, v);
	print(mm);

	Matrix * m3 = mult(m1, mm);
	print(m3);
	/*
	Matrix * m4 = mult(m1, v2);
	print(m4);
	Matrix * m5 = plus(m3, m4);
	print(m5);
	destroy(v1);
	destroy(v2);
	destroy(m1);
	destroy(m2);
	destroy(mm);
	destroy(m3);
	destroy(m4);
	destroy(m5);
	*/
	int z; std::cin >> z;

	return 0;
}

Vector * clone(Vector * v) {
    Vector *x = new Vector;
    x->data = new DataType[v->size];
    for (int i=0;i<v->size;i++)
        x->data[i].value = v->data[i].value;
    memcpy(x,v,sizeof(v));
    return x;
}