#include <iostream>
typedef enum VarType { vtInteger, vtComplex, vtCompMatrix };
using namespace std;
class Variable
{
protected:
VarType type;
bool fiction;
public:
Variable()
{
fiction = false;
}
Variable(Variable * v1)
{
}
virtual ~Variable()
{
}
protected:
void SetFiction(bool fl)
{
fiction = fl;
}
virtual Variable * Create()
{
return new Variable();
}
virtual Variable * Copy(Variable * v)
{
return this;
}
void ChooseOperands(Variable * p2, Variable ** op1, Variable ** op2)
{
if (fiction)
{
(* op1) = this;
(* op2) = p2;
}
else
{
(* op1) = (Create())->Copy(this);
(* op1)->SetFiction(true);
(* op2) = p2;
}
}
void CheckFiction(Variable * op2)
{
if (op2->fiction)
delete op2;
}
public:
virtual void Add(Variable * op1) { };
virtual void Sub(Variable * op1) { };
virtual void Mul(Variable * op1) { };
virtual void Div(Variable * op1) { };
Variable & operator+(Variable & p1)
{
Variable * op1 = NULL, * op2 = NULL;
ChooseOperands(&p1, &op1, &op2);
op1->Add(op2);
CheckFiction(op2);
return (* op1);
}
Variable & operator-(Variable & p1)
{
Variable * op1 = NULL, * op2 = NULL;
ChooseOperands(&p1, &op1, &op2);
op1->Sub(op2);
CheckFiction(op2);
return (* op1);
}
Variable & operator*(Variable & p1)
{
Variable * op1 = NULL, * op2 = NULL;
ChooseOperands(&p1, &op1, &op2);
op1->Mul(op2);
CheckFiction(op2);
return (* op1);
}
Variable & operator/(Variable & p1)
{
Variable * op1 = NULL, * op2 = NULL;
ChooseOperands(&p1, &op1, &op2);
op1->Div(op2);
CheckFiction(op2);
return (* op1);
}
Variable & operator=(Variable & p1)
{
Copy(&p1);
CheckFiction(&p1);
return (* this);
}
};
class Integer: public Variable
{
public:
int value;
Integer()
{
type = vtInteger;
value = 0;
}
Integer(int nv)
{
type = vtInteger;
value = nv;
}
Integer(Integer * v1)
{
type = vtInteger;
value = v1->value;
}
virtual ~Integer()
{
}
virtual Variable * Create()
{
return new Integer();
}
virtual Variable * Copy(Variable * v)
{
value = ((Integer *) v)->value;
return this;
}
virtual void Add(Variable * op1)
{
value += ((Integer *) op1)->value;
}
virtual void Sub(Variable * op1)
{
value -= ((Integer *) op1)->value;
}
virtual void Mul(Variable * op1)
{
value *= ((Integer *) op1)->value;
}
virtual void Div(Variable * op1)
{
value /= ((Integer *) op1)->value;
}
Integer & operator=(Variable & p1)
{
Variable::operator=(p1);
return (* this);
}
};
class Complex: public Variable
{
protected:
double a;
double b;
public:
Complex()
{
type = vtComplex;
a = 0;
b = 0;
}
Complex(double na, double nb)
{
type = vtComplex;
a = na;
b = nb;
}
Complex(Complex * v1)
{
type = vtComplex;
a = v1->a;
b = v1->b;
}
virtual ~Complex()
{
}
virtual Complex * Create()
{
return new Complex();
}
virtual Complex * Copy(Variable * v)
{
a = ((Complex *) v)->a;
b = ((Complex *) v)->b;
return this;
}
virtual void Add(Variable * op1)
{
a += ((Complex *) op1)->a;
b += ((Complex *) op1)->b;
cout << "a: " << a << endl << "b: " << b << endl;
}
virtual void Sub(Variable * op1)
{
a -= ((Complex *) op1)->a;
b -= ((Complex *) op1)->b;
cout << "a: " << a << endl << "b: " << b << endl;
}
virtual void Mul(Variable * op1)
{
double a1 = a, b1 = b, a2 = ((Complex *) op1)->a, b2 = ((Complex *) op1)->b;
a = (a1 * a2) - (b1 * b2);
b = (a1 * b2) + (b1 * a2);
cout << "a: " << a << endl << "b: " << b << endl;
}
virtual void Div(Variable * op1)
{
double a1 = a, b1 = b, a2 = ((Complex *) op1)->a, b2 = ((Complex *) op1)->b;
double d = (a2*a2 + b2*b2);
a = (a1*a2 + b1*b2) / d;
b = (a2*b1 - b2*a1) / d;
cout << "a: " << a << endl << "b: " << b << endl;
}
Complex & operator=(Variable & p1)
{
Variable::operator=(p1);
Complex * p2 = (Complex *) &p1;
cout << "a: " << p2->GetA() << endl << "b: " << p2->GetB() << endl;
return (* this);
}
double GetA()
{
return a;
}
double GetB()
{
return b;
}
void Clear()
{
a = 0;
b = 0;
}
void SetA(double na)
{
a = na;
}
void SetB(double nb)
{
b = nb;
}
void SetAB(double na, double nb)
{
a = na;
b = nb;
}
};
struct CompBlock
{
unsigned nColumn;
Complex value;
CompBlock()
{
nColumn = 0;
}
};
typedef CompBlock * pCompBlock ;
class CompMatrix: public Variable
{
protected:
CompBlock * * index;
CompBlock * vector;
unsigned m;
unsigned n;
int curQty;
int maxQty;
unsigned brQty;
unsigned br[2];
public:
CompMatrix()
{
type = vtCompMatrix;
index = NULL;
vector = NULL;
m = 0;
n = 0;
maxQty = 0;
curQty = 0;
brQty = 0;
br[0] = 0;
br[1] = 0;
}
void Init(int m0, int n0, int mq0)
{
if (vector)
delete vector;
if (index)
delete index;
m = m0;
n = n0;
maxQty = mq0;
index = new pCompBlock[m];
memset(index, 0, sizeof(CompBlock)*m);
vector = new CompBlock[maxQty];
}
Complex GetValue()
{
int m0 = br[0], n0 = br[1];
br[0] = 0;
br[1] = 0;
brQty = 0;
printf("%d | %d\n", m0, n0);
CompBlock * cp = index[m0];
for (unsigned i=0; i<n; i++)
if (cp[i].nColumn == n0)
return cp[i].value;
Complex Blank;
Blank.Clear();
return Blank;
}
Complex & SetValue()
{
static Complex Blank;
unsigned m0 = br[0], n0 = br[1];
br[0] = 0;
br[1] = 0;
brQty = 0;
CompBlock * newBlock = index[m0];
CompBlock * nextBlock = NULL;
unsigned rowLen = 0;
for (unsigned i=m0+1; i<m; i++)
if (index[i])
nextBlock = index[i];
if (newBlock)
{
if (nextBlock)
rowLen = unsigned(nextBlock - newBlock) / sizeof(CompBlock);
for (unsigned i=0; i<rowLen; i++)
if (newBlock[i].nColumn == n0)
return newBlock->value;
if (curQty < maxQty)
{
memcpy(newBlock, newBlock + 1, ((curQty - n0) * sizeof(CompBlock)));
for (unsigned i=m0+1; i<m; i++)
if (index[i])
index[i]++;
newBlock->nColumn = n0;
newBlock->value.Clear();
return newBlock->value;
}
else
{
Blank.Clear();
return Blank;
}
}
else //28.05.08 21:00
{
if (curQty < maxQty)
{
if (nextBlock)
{
index[m0] = nextBlock;
memcpy(nextBlock, nextBlock + 1, ((curQty - m0) * sizeof(CompBlock)));
index[m0]->value.Clear();
for (unsigned i=m0+1; i<m; i++)
if (index[i])
index[i]++;
curQty++;
return index[m0]->value;
}
else
{
index[m0] = vector + curQty;
curQty++;
vector[curQty].nColumn = n0;
return vector[curQty].value;
}
}
else
{
Blank.Clear();
return Blank;
}
}
}
CompMatrix & operator[](unsigned p1)
{
br[brQty++] = p1;
return (* this);
}
};
class VirtualArray
{
protected:
VirtualArray * next;
Complex value;
int position;
public:
VirtualArray()
{
next = NULL;
position = 0;
}
VirtualArray(Complex v, int p)
{
//Complex
}
void Add(Complex v, int p)
{
if (position != p)
{
if (next)
next->Add(v, p);
else
next = new VirtualArray(v, p);
}
else
{
value.Copy(&v);
}
}
void Clear()
{
}
Complex & operator[](int p)
{
return value;
}
};
int main()
{
Complex v1(1,2), v2(3,4), v3(6,7), v4(8,2), v5(7,3);
CompMatrix vm;
vm.Init(5, 5, 5);
vm[1][1].SetValue() = v1;
vm[2][2].SetValue() = v2;
vm[3][3].SetValue() = v3;
vm[4][4].SetValue() = v4;
//vm[5][5].SetValue() = v5;
for (int i=0; i<5; i++)
for (int j=0; j<5; j++)
printf("v[%d][%d] = %f | %f\n", i, j, vm[i][j].GetValue().GetA(), vm[i][j].GetValue().GetB());
//v5 = ((v1 + v2) / (v3 - v4));
//cout << v5.GetA() << endl <<v5.GetB() << endl;
getchar();
return 0;
}
kursach07