public static Matrix Shift(Matrix x, int maxShiftX, int maxShiftY)
{
var xShift = rand.Next(-maxShiftX, maxShiftX);
var yShift = rand.Next(-maxShiftY, maxShiftY);
var res = x.Copy();
res.Shift(xShift, yShift);
return res;
}
public void Copy_should_create_copy()
{
//Arrange
var sourceArray = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
var source = new Matrix<int>(sourceArray, 3, 4);
//Act
var copy = source.Copy();
//Assert
Assert.IsNotNull(copy);
Assert.AreNotSame(source, copy);
Assert.AreNotSame(source.Data, copy.Data);
Assert.AreEqual(source.Size, copy.Size);
Assert.AreEqual(source.NumRows, copy.NumRows);
Assert.AreEqual(source.NumColumns, copy.NumColumns);
for(int i = 0; i < source.Data.Length; i++)
{
Assert.AreEqual(source.Data[i], copy.Data[i]);
}
}
/// <summary>
/// Metodo del rilassamento o di bisezione
/// ALGORITMO ERRATO.
/// </summary>
/// <param name="guess"></param>
/// <param name="xmin"></param>
/// <param name="beta"></param>
/// <param name="toll"></param>
/// <param name="prec"></param>
/// <param name="iterazioni"></param>
/// <returns></returns>
public bool TrovaMinimo2(Matrix guess, ref Matrix xmin, double beta, double toll, double prec, ref int iterazioni)
{
bool trovato = false;
int i;
Matrix xk, dk, xk1;
xk = guess.Copy(); // Impostazioni iniziali
xk1 = xk.Copy();
double dist;
for(i=0; i < iterazioni; i++)
{
int indx = i % guess.Row;
dk = - Gradiente(xk,indx);
Matrix scal = (!dk) * dk;
dist = scal.Get(0,0); // Modulo, se vettore lineare
if(dist > toll)
{
Matrix xk1new = xk + beta * dk;
xk = xk1.Copy(); // Ricalcola
xk1 = xk1new.Copy();
}
else if(Math.Abs(Funzione(xk)-Funzione(xk1)) < prec)
{
trovato = true;
iterazioni = i;
xmin = xk.Copy();
break;
}
}
return trovato;
}
/*
NOTA GENERALE.
I metodi precedenti, steepest descent, rilassamento (per la scelta delle direzioni) e
passo fisso e bisezione (per la ricerca del minimo (o del massimo)
non sono sufficienti da soli.
E' ragionevole scrivere prima alcune funzioni che lavorino separatamente.
Tutte sono incluse nella classe Fmin e hanno gia` implicito il delegate alla funzione
Tutte devono prima verificare che il delegate non sia nullo.
*/
/// <summary>
/// Ricerca per punti
/// </summary>
/// <param name="xk">Punto centrale</param>
/// <param name="range">Meta` ampiezza di ricerca (ammessi valori nulli)</param>
/// <param name="passiU">Numero di passi unilaterali (almeno 1)</param>
/// <param name="xmin">Punto con il valore minore</param>
/// <param name="cicli">Numero di punti calcolati</param>
/// <returns></returns>
public bool Campionamento( Matrix xk,
Matrix range,
MatrixBase<int> passiU,
ref Matrix xmin,
ref int cicli)
{
bool found = false;
int n; // Dimensioni dei vettori
int i; // Contatore
n = xk.Row;
if((range.Row != n) || (passiU.Row != n) || (xmin.Row != n) || (xk.Col != 1) || (range.Col != 1) || (passiU.Col != 1) || (xmin.Col != 1) )
{
return found; // Verifica indici
}
for(i=0; i<n; i++) // Verifica intervalli (ammessi valori nulli)
{
if(range.Get(i,0) < 0.0)
{
return found;
}
}
for(i=0; i<n; i++) // Verifica passi (almeno 1 per lato)
{
if(passiU.Get(i,0) < 1)
{
return found;
}
}
MatrixBase<int> passi = new MatrixBase<int>(n,1); // Matrice dei passi
for(i=0; i<n; i++) // Calcola i passi effettivi (segmenti, non punti)
{
passi.Set(i, 0, passiU.Get(i,0) * 2);
}
Matrix step = new Matrix(n,1);
for(i=0; i<n; i++) // Calcola i passi effettivi
{
step.Set(i, 0, range.Get(i,0)/passi.Get(i,0));
}
Matrix xo = new Matrix(n,1);
for(i=0; i<n; i++) // Calcola i punti di partenza
{
xo.Set(i, 0, xk.Get(i,0) - step.Get(i,0) * passiU.Get(i,0));
}
MatrixBase<int> contatori = new MatrixBase<int>(n,1,0); // Vettore dei contatotri (tutti a 0)
Matrix x = new Matrix(n,1); // Vettore dei valori effettivi
int iinc = -1;
double minimo = double.MaxValue;
double f;
cicli = 0;
bool fine = false;
while(!fine)
{
if(iinc >= 0) // ricalcola nuovo vettore x
{
x.Set( iinc,0, xo.Get(iinc,0) + step.Get(iinc,0) * contatori.Get(iinc,0) );
}
else
{
for(i=0; i<n; i++)
x.Set( i,0, xo.Get(i,0) + step.Get(i,0) * contatori.Get(i,0) );
}
f = Funzione(x); // Calcola la f del punto x attuale
if(f < minimo) // Vede se e` minima (rispetto ai valori trovati finora)
{
minimo = f;
xmin = x.Copy();
found = true;
}
fine = !Incrementa(ref contatori, passi, ref iinc);
cicli++;
}
return found;
}