static void Main(string[] args)
{
Macierz a = new Macierz(3, 2), b = new Macierz(3, 2);
a.InicjalizujMacierz();
Console.WriteLine("Macierz A: ");
a.WypiszMacierz();
Console.WriteLine("\nMacierz B: ");
b.InicjalizujMacierz();
b.WypiszMacierz();
Console.WriteLine("\nMacierz A + B: ");
(a + b).WypiszMacierz();
Console.WriteLine("\nMacierz A - B: ");
(a - b).WypiszMacierz();
Console.WriteLine("\nMacierz 2 * A: ");
(2 * a).WypiszMacierz();
Macierz c = new Macierz(2, 1);
c.InicjalizujMacierz();
Console.WriteLine("\nMacierz C: ");
c.WypiszMacierz();
Console.WriteLine("\nMacierz A * C: ");
(a * c).WypiszMacierz();
Macierz d = (Macierz)33;
Console.WriteLine("\nMacierz D: ");
d.WypiszMacierz();
Console.ReadKey();
}
public static void InicjalizujMacierz(this Macierz a)
{
for (int i = 1; i <= a.LiczbaWierszy; i++)
{
for (int j = 1; j <= a.LiczbaKolumn; j++)
{
a[i, j] = generator.Next(0, 11);
}
}
}
public void DodajMacierz(Macierz inp)
{
if ((inp.lkolumn != this.lkolumn) || (inp.lwierszy != this.lwierszy))
{
Console.WriteLine("Dodawanie niemożliwe, błędne parametry");
}
else
{
for (int i = 0; i < this.lwierszy; i++)
{
this.wiersze[i].DodajWektor(inp.ZwrocWiersz(i));
}
}
}
static void Main()
{
Wektor w = new Wektor(new float[] { 9.0f, 7.4f, 2f, 2.1f });
Wektor w2 = new Wektor(new float[] { 7f, 3f, 2f, 1f });
Wektor w4 = new Wektor(new float[] { 2f, 3f });
Wektor w5 = new Wektor(new float[] { 12f, 4f });
Wektor w6 = new Wektor(new float[] { 2f, 5.2f });
Wektor w7 = new Wektor(new float[] { 12.1f, 9f });
Console.Write("wektor w: ");
w.drukujWektor();
Console.Write("wektor w2: ");
w2.drukujWektor();
Wektor w3 = Wektor.dodaj(w, w2);
Console.Write("wektor w+w2: ");
w3.drukujWektor();
Macierz m = new Macierz(new Wektor[] { w, w2, w3 });
Console.Write("\nmacierz m: \n");
m.drukujMacierz();
Macierz m2 = new Macierz(new Wektor[] { w4, w5, w6, w7 });
Console.Write("\nmacierz m2: \n");
m2.drukujMacierz();
Macierz wynik = Macierz.iloczynMacierzy(m, m2);
Console.Write("\nmacierz m*m2:\n");
wynik.drukujMacierz();
Macierz dod = Macierz.sumaMacierzy(m, m);
Console.Write("\nmacierz m+m:\n");
dod.drukujMacierz();
Wektor v = Macierz.ilocznynMacierzWek(m, w3);
Console.Write("\nwektor m*(w+w2): ");
v.drukujWektor();
Macierz.sumaMacierzy(m, m2);
Wektor.dodaj(w, w4);
}
public static Wektor ilocznynMacierzWek(Macierz m, Wektor w)
{
if (w.vectorSize() != m.cols)
{
Console.WriteLine("\nNie mozna przemnozyc macierzy przez wektor.");
return(null);
}
int i;
Wektor wynik = new Wektor(m.rows);
for (i = 0; i < m.rows; i++)
{
wynik.wektor[i] = Wektor.iloczynSkalarny(m.macierz[i], w);
}
return(wynik);
}
public static void WypiszMacierz(this Macierz a)
{
Console.Write("[ ");
for (int i = 1; i <= a.LiczbaWierszy; i++)
{
Console.Write("<");
for (int j = 1; j <= a.LiczbaKolumn; j++)
{
Console.Write(a[i, j]);
if (j != a.LiczbaKolumn)
{
Console.Write("; ");
}
}
Console.Write("> ");
}
Console.Write("]");
}
public static Macierz sumaMacierzy(Macierz m1, Macierz m2)
{
if (m1.cols != m2.cols || m1.rows != m2.rows)
{
Console.WriteLine("\nMacierze roznych rozmiarow. Nie mozna dodac.");
return(null);
}
Macierz wynik = new Macierz(m1.rows, m1.cols);
int i, j;
for (i = 0; i < m1.rows; i++)
{
for (j = 0; j < m1.cols; j++)
{
wynik.macierz[i].wektor[j] = m1.macierz[i].wektor[j] + m2.macierz[i].wektor[j];
}
}
return(wynik);
}
private Wektor fR; //wektor przesunięcia układu obserwatora;
//---------------------------------------------------------------------------
// Konstruktor główny, inicjujący wszystkie parametry przekształcenia 3d
// Trzy ostatnie paramtry (metryczny opis ekranu) nie są wymagane -
// zostaną obliczone ze wymiarów pikselowych i standardowej pozycji
// komputerowca przed monitorem .
public T3d(Punkt obs, //pozycja obserwatora
int xe0, int ye0, int eszer, int ewys, //okno ekranowe w pikselach
float odl_ekr = 0, //typowa odległość oczu od monitora
float szer_ekr = 0, float wys_ekr = 0) //fizyczny opis ekranu w metrach
{
Punkt centrum = new Punkt(0, 0, 0); //tam patrzy obserwator
Wektor pion = new Wektor(0, 0, 1); //pomocniczy wektor, orientujący obserwatora w 3d
if (odl_ekr <= 0)
{
odl_ekr = 0.5f;
}
if (szer_ekr <= 0) //gdy nie określono rozmiarów ekranu
{
szer_ekr = (float)eszer * 0.0257f / 96.0f; //0.0257 m = 1 cal. Ekran ma 96 pikseli/cal
}
if (wys_ekr <= 0)
{
wys_ekr = (float)ewys * 0.0257f / 96.0f;
}
s = new Skala(xe0, ye0, eszer, ewys, 0, 0, szer_ekr, wys_ekr);
Wektor w3 = new Wektor(obs, centrum); //lokalny wektor z obserwatora (wkazujący środek układu)
w3.unormuj();
Wektor w1 = new Wektor();
w1 = (pion ^ w3); //lokalny wektor osi x' obserwatora
w1.unormuj();
Wektor w2 = new Wektor();
w2 = (w3 ^ w1); //lokalny wektor osi y' obserwatora
w1 = -w1; //lewoskrętność układu obserwatora
M = new Macierz(w1, w2, w3); //macierz przekształcenia
fodl_ekr = odl_ekr; //parametry potrzebne innym funkcjom
fR = new Wektor(obs, new Punkt()); //tyle dystansu dzieli układy odniesienia
}
// m1*m2
public static Macierz iloczynMacierzy(Macierz m1, Macierz m2)
{
Macierz wynik = new Macierz(m1.rows, m2.cols);
int i, j, k;
float w = 0f;
for (i = 0; i < m1.rows; i++)
{
for (j = 0; j < m2.cols; j++)
{
w = 0f;
// iloczyn skalarny i-tego wiersza m1 i j-tej kol. m2
for (k = 0; k < m1.cols; k++)
{
w += m1.macierz[i].wektor[k] * m2.macierz[k].wektor[j];
}
wynik.macierz[i].wektor[j] = w;
}
}
return(wynik);
}
public Wektor.Macierz Przemnoz(Macierz inp)
{
if (this.lkolumn != inp.lwierszy)
{
Console.WriteLine("Invalid input");
return(default(Wektor.Macierz));
}
Wektor[] scratch = new Wektor[this.lwierszy];
for (int i = 0; i < this.lwierszy; i++)
{
float[] nowy_wiersz = new float[this.lkolumn];
for (int k = 0; k < this.lkolumn; k++)
{
for (int j = 0; j < inp.lwierszy; j++)
{
nowy_wiersz[k] += (this.ZwrocWiersz(i)).ZwrocReprezentacje(j + 1) * (inp.ZwrocWiersz(j)).ZwrocReprezentacje(k + 1);
}
}
Wektor pom = new Wektor(nowy_wiersz);
scratch[i] = pom;
}
Wektor.Macierz temp = new Wektor.Macierz(scratch);
return(temp);
}
public double fitting(WykresModel dane, UstawieniaModel.Wykres ustawienia)
{
Macierz macierz = new Macierz();
int index = ustawienia.pik_mapa;
bool _1000_p = false;
bool _1000_m = false;
for (int i = 0; i < dane.punkty.Count - 1; i++)
{
double y = (double)dane.get_y(index);
double y2 = Math.Pow((double)dane.get_y(index), 2);
if (i == 0)
{
Ey2 += y2;
Elny2 += y2 * Math.Log(y);
}
else
{
double yminus = (double)dane.get_y(index - i);
double yplus = (double)dane.get_y(index + i);
double y2minus = Math.Pow((double)dane.get_y(index - i), 2);
double y2plus = Math.Pow((double)dane.get_y(index + i), 2);
double xminus = (double)dane.get_x(index - i) - dane.get_x(index);
double xplus = (double)dane.get_x(index + i) - dane.get_x(index);
if (yminus > 1000)
{
Ey2 += y2minus;
Exy2 += xminus * y2minus;
Ex2y2 += Math.Pow(xminus, 2) * y2minus;
Ex3y2 += Math.Pow(xminus, 3) * y2minus;
Ex4y2 += Math.Pow(xminus, 4) * y2minus;
Elny2 += Math.Log(yminus) * y2minus;
Exlny2 += xminus * Math.Log(yminus) * y2minus;
Ex2lny2 += Math.Pow(xminus, 2) * Math.Log(yminus) * y2minus;
}
else
{
_1000_m = true;
}
if (yplus > 1000)
{
Ey2 += y2plus;
Exy2 += xplus * y2plus;
Ex2y2 += Math.Pow(xplus, 2) * y2plus;
Ex3y2 += Math.Pow(xplus, 3) * y2plus;
Ex4y2 += Math.Pow(xplus, 4) * y2plus;
Elny2 += Math.Log(yplus) * y2plus;
Exlny2 += xplus * Math.Log(yplus) * y2plus;
Ex2lny2 += Math.Pow(xplus, 2) * Math.Log(yplus) * y2plus;
}
else
{
_1000_p = true;
}
}
if (_1000_m == true && _1000_p == true)
{
break;
}
}
double[,] nowa_macierz = new double[, ] {
{ Ey2, Exy2, Ex2y2 },
{ Exy2, Ex2y2, Ex3y2 },
{ Ex2y2, Ex3y2, Ex4y2 }
};
detA = macierz.oblicz(nowa_macierz);
double[,] nowa_macierz1 = new double[, ] {
{ Elny2, Exy2, Ex2y2 },
{ Exlny2, Ex2y2, Ex3y2 },
{ Ex2lny2, Ex3y2, Ex4y2 }
};
detA1 = macierz.oblicz(nowa_macierz1);
nowa_macierz = new double[, ] {
{ Ey2, Elny2, Ex2y2 },
{ Exy2, Exlny2, Ex3y2 },
{ Ex2y2, Ex2lny2, Ex4y2 }
};
detA2 = macierz.oblicz(nowa_macierz);
nowa_macierz = new double[, ] {
{ Ey2, Exy2, Elny2 },
{ Exy2, Ex2y2, Exlny2 },
{ Ex2y2, Ex3y2, Ex2lny2 }
};
detA3 = macierz.oblicz(nowa_macierz);
a = detA1 / detA;
b = detA2 / detA;
c = detA3 / detA;
mikro = -b / (2 * c);
kond = Math.Sqrt(-1 / (2 * c));
A = Math.Exp(a - (b * b) / (4 * c));
FWHM = 2 * Math.Sqrt(2 * Math.Log(2)) * kond;
if (c < 0 && c > -2)
{
return(A);
}
return(0);
}
