// sablonnal létrehozott referencia osztály
// sablon típusa T, létrehozáskor töltődik ki
template <class T>
ref class Complex {
private:
	// valós és képzetes rész private adattagja T típussal
	T re, im;
public:
	//konstruktorok
	Complex() : im(0), re(0) {};
	Complex(T re, T im) : im(im), re(re) {};
	// írható/olvasható property
	// valós rész
	property T Re {
		T get() { return re; }
		void set(T re) { this->re = re; }
	}
	// írható/olvasható property
	// képzetes rész
	property T Im {
		T get() { return im; }
		void set(T im) { this->im = im; }
	}
	// az ősosztályból származó ToString() metódus felüldefiniálása
	// az override kulcsszót ki kell tenni
	String^ ToString() override	{
		String^ s = gcnew String("");
		// ha nulla
		if (re == 0 && im == 0) s = "0";
		// ha van valós rész
		if (re != 0) s = Convert::ToString(re);
		// ha van mindkettő és im +
		if (re != 0 && im > 0) s += "+";
		// ha im -
		if (im < 0) s += "-";
		// im abszolút értéke
		if (im != 0) s += Convert::ToString(Math::Abs(im)) + "i";
		return s;
	}
	// + operátor, komplex számok összege
	Complex<T>^ operator + (Complex<T>^ cm) {
		return gcnew Complex<T>(re + cm->Re, im + cm->Im);
	}
	// * operátor, komplex számok szorzata
	Complex<T>^ operator * (Complex<T>^ cm) {
		T a = re, b = im, c = cm->Re, d = cm->Im;
		return gcnew Complex<T>(a * c - b * d, b * c + a * d);
	}
};

// 2D-s pont
ref class p2D {
public:
	float x, y;
	p2D(float x, float y) :x(x), y(y) {};
};

// 3D-s pont
ref class p3D {
public:
	float x, y, z;
	p3D(float x, float y, float z) :x(x), y(y), z(z) {};
};

// Vetítés interfészelése
interface class Vetites {
public:
	p2D^ vetit(p3D^ be);
};

// Axonometikus vetítést megvalósító osztály
ref class Axonometrikus : Vetites {
public:
	float qx, qy, qz, alfa, beta, gamma;
	Axonometrikus(float qx, float qy, float qz, float alfa, float beta, float gamma)
		: qx(qx), qy(qy), qz(qz), alfa(alfa), beta(beta), gamma(gamma) {}
	virtual p2D^ vetit(p3D^ be) {
		return gcnew p2D(-be->x * qx * Math::Cos(deg2rad(alfa)) +
						be->y * qy * Math::Cos(deg2rad(beta)) +
						-be->z * qz * Math::Sin(deg2rad(gamma)),
						-be->x * qx * Math::Sin(deg2rad(alfa)) +
						-be->y * qy * Math::Sin(deg2rad(beta)) +
						be->z * qz * Math::Cos(deg2rad(gamma))
		);
	}
};

// Centrális vetítést megvalósító osztály
ref class Centralis : Vetites {
public:
	float d, zmin = 2;
	Centralis(float d) :d(d), zmin(2) {};
	Centralis(float d, float zmin) :d(d), zmin(zmin) { if (zmin < 2) zmin = 2; };
	virtual p2D^ vetit(p3D^ be) {
		return gcnew p2D(be->x * d / (be->z + zmin),	// z eltolása, mert 0 távolságból
						be->y * d / (be->z + zmin));				// végtelen nagy lenne a kép
	}
};

// fok -> rad átváltó
static float deg2rad(float fok) {
	return fok * Math::PI / 180;
}

// Képernyőre helyezés
ref class WindowViewPort {
public:
	int x, y, n;
	WindowViewPort(int x, int y, int n) :x(x), y(y), n(n) {};
	PointF wvport(p2D^ vp) {
		return PointF(vp->x * n + x, y - vp->y * n);
	}
};

// 3D-s pont levetítése és megjelenítése a képernyőn
void Draw3DLine(Graphics^ gr, Pen^ toll, p3D^ p1_3d, p3D^ p2_3d, Vetites^ v, WindowViewPort^ w) {
	p2D^ p1_2d = v->vetit(p1_3d);
	p2D^ p2_2d = v->vetit(p2_3d);
	PointF p1 = w->wvport(p1_2d);
	PointF p2 = w->wvport(p2_2d);
	gr->DrawLine(toll, p1, p2);
}

ora1.m

%változók
%valós
k = 2
s = 3.6
%komplex
z = 3+4*i
r = 5*exp(i*pi/3)
% workspace-ben található változók
whos
% komplex szám j betűvel
j = sqrt(-1)
% e szám
e = exp(1)
%kiiratás
disp('i^2=');
disp(i^2);

%másodfokú függvény
a=1; b=-3; c=10;
d = b^2 - 4*a*c;
x1 = (-b+sqrt(d))/(2*a);
x2 = (-b-sqrt(d))/(2*a);
disp(['x1=',num2str(x1), ' x2=',num2str(x2,15)]);
%komplex részek
x1i = imag(x1);
x2i = imag(x2);
fprintf('x1=%.2f%+.2fi x2=%.2f%+.2fi\n',x1,x1i,x2,x2i);

%vektor
x = [1 , 2, 3];  %sorvektor , vagy space
q = [4; 5; 6];   % oszlop vektor ;
v = [4, 5 , 6]';  %transzponált jele '
%mátrix
A = [7, 8, 9; 5, 6, 7]; % A egy 2x3-as mátrix

%polinomok
v = [a b c]; %másodfokú fgv
p=roots(v);  %gyökei
v1 = poly(p); %polinom a gyökök alapján P(x)=(x- p1)(x- p2)...(x- pn)
disp('polinommal')
disp(p)

u=1:3; % létrehozza a u=[1 2 3] vektort, » u=start:stop
w=1:2:10; % létrehozza a w=[1 3 5 7 9] vektort, » =start:increment:stop

x = linspace(1,10); % kezdet, vég  100 egységre osztva
y = linspace(1,10,19); % kezdet, vég , 50 egyszégre osztva

%mátrix
E = eye(4);		%egység mátrix
B = eye(3,4);
C = zeros(2,4); %csupa 0
D = ones(3,5);  %csupa 1

%elemek elérése
A(2,3); %sor, oszlop , indexelés 1-től
v(2) = -6; %érték megadás
v(5)= 2    % bövítés új elemmel

A(:,1); %1.oszlop
A(2,:); %2.sor
A(2,2:3) %2.sor 2,3 eleme

%mátrix mérete
[sor , oszlop]=size(A);


%adott változó törlése
clear A
%összes változó törlése
clear
format long; % kiiratás 15 jegyig

%műveletek vektorokkal
x = [-1 0 2]';
y = x -1;
2*x;
s = x'*y;  %skaláris szorzás
M = x*y';  %diadikus szorzat

b = M *x;  %mátrix szorzása vektorral

x.*y    %elemenkénti műveletek
		
% x+y=2
% 2x+4y=6
fprintf('a');
A = [ 1 1; 2 4];
b = [ 2;6];
% x = inv(A)*b;
x = A\b;
disp('2x2-es lineáris egyenletrendszer: ');
disp(x);

x = input('Meddig nézzek prímeket?');
y = primes(x);
%disp('Prímszámok:');
%disp(y);
fprintf('Prímszámok: ');
fprintf('%i ',y);
fprintf('\n');


x = input('Minek a faktoriálisát számítsam ki?');
j = 1;
for k = 1:x 
   j = j*k;
   %fprintf('%i != %i\n',k,j);
end   
fprintf('%i != %i\n',x,j);
		

ora2.m

% Hamarosan ...