/**
* <p>
* Given a set of polynomial coefficients, compute the roots of the polynomial. Depending on
* the polynomial being considered the roots may contain complex number. When complex numbers are
* present they will come in pairs of complex conjugates.
* </p>
*
* <p>
* Coefficients are ordered from least to most significant, e.g: y = c[0] + x*c[1] + x*x*c[2].
* </p>
*
* @param coefficients Coefficients of the polynomial.
* @return The roots of the polynomial
*/
public static Complex_F64[] findRoots(params double[] coefficients)
{
int N = coefficients.Length - 1;
// Construct the companion matrix
DMatrixRMaj c = new DMatrixRMaj(N, N);
double a = coefficients[N];
for (int i = 0; i < N; i++)
{
c.set(i, N - 1, -coefficients[i] / a);
}
for (int i = 1; i < N; i++)
{
c.set(i, i - 1, 1);
}
// use generalized eigenvalue decomposition to find the roots
EigenDecomposition_F64 <DMatrixRMaj> evd = DecompositionFactory_DDRM.eig(N, false);
evd.decompose(c);
Complex_F64[] roots = new Complex_F64[N];
for (int i = 0; i < N; i++)
{
roots[i] = evd.getEigenvalue(i);
}
return(roots);
}
/**
* <p>
* The condition p = 2 number of a matrix is used to measure the sensitivity of the linear
* system <b>Ax=b</b>. A value near one indicates that it is a well conditioned matrix.<br>
* <br>
* κ<sub>2</sub> = ||A||<sub>2</sub>||A<sup>-1</sup>||<sub>2</sub>
* </p>
* <p>
* This is also known as the spectral condition number.
* </p>
*
* @param A The matrix.
* @return The condition number.
*/
public static double conditionP2(DMatrixRMaj A)
{
SingularValueDecomposition_F64 <DMatrixRMaj> svd =
DecompositionFactory_DDRM.svd(A.numRows, A.numCols, false, false, true);
svd.decompose(A);
double[] singularValues = svd.getSingularValues();
int n = SingularOps_DDRM.rank(svd, UtilEjml.TEST_F64);
if (n == 0)
{
return(0);
}
double smallest = double.MaxValue;
double largest = double.MinValue;
foreach (double s in singularValues)
{
if (s < smallest)
{
smallest = s;
}
if (s > largest)
{
largest = s;
}
}
return(largest / smallest);
}
/**
*
* @param computeVectors
* @param tol Tolerance for a matrix being symmetric
*/
public SwitchingEigenDecomposition_DDRM(int matrixSize, bool computeVectors, double tol)
{
symmetricAlg = DecompositionFactory_DDRM.eig(matrixSize, computeVectors, true);
generalAlg = DecompositionFactory_DDRM.eig(matrixSize, computeVectors, false);
this.computeVectors = computeVectors;
this.tol = tol;
}
/**
* <p>
* Checks to see if the matrix is positive semidefinite:
* </p>
* <p>
* x<sup>T</sup> A x ≥ 0<br>
* for all x where x is a non-zero vector and A is a symmetric matrix.
* </p>
*
* @param A square symmetric matrix. Not modified.
*
* @return True if it is positive semidefinite and false if it is not.
*/
public static bool isPositiveSemidefinite(DMatrixRMaj A)
{
if (!isSquare(A))
{
return(false);
}
EigenDecomposition_F64 <DMatrixRMaj> eig = DecompositionFactory_DDRM.eig(A.numCols, false);
if (eig.inputModified())
{
A = (DMatrixRMaj)A.copy();
}
eig.decompose(A);
for (int i = 0; i < A.numRows; i++)
{
Complex_F64 v = eig.getEigenvalue(i);
if (v.getReal() < 0)
{
return(false);
}
}
return(true);
}
/**
* Computes a basis (the principal components) from the most dominant eigenvectors.
*
* @param numComponents Number of vectors it will use to describe the data. Typically much
* smaller than the number of elements in the input vector.
*/
public void computeBasis(int numComponents)
{
if (numComponents > A.getNumCols())
{
throw new ArgumentException("More components requested that the data's length.");
}
if (sampleIndex != A.getNumRows())
{
throw new ArgumentException("Not all the data has been added");
}
if (numComponents > sampleIndex)
{
throw new ArgumentException("More data needed to compute the desired number of components");
}
this.numComponents = numComponents;
// compute the mean of all the samples
for (int i = 0; i < A.getNumRows(); i++)
{
for (int j = 0; j < mean.Length; j++)
{
mean[j] += A.get(i, j);
}
}
for (int j = 0; j < mean.Length; j++)
{
mean[j] /= A.getNumRows();
}
// subtract the mean from the original data
for (int i = 0; i < A.getNumRows(); i++)
{
for (int j = 0; j < mean.Length; j++)
{
A.set(i, j, A.get(i, j) - mean[j]);
}
}
// Compute SVD and save time by not computing U
SingularValueDecomposition <DMatrixRMaj> svd =
DecompositionFactory_DDRM.svd(A.numRows, A.numCols, false, true, false);
if (!svd.decompose(A))
{
throw new InvalidOperationException("SVD failed");
}
V_t = svd.getV(null, true);
DMatrixRMaj W = svd.getW(null);
// Singular values are in an arbitrary order initially
SingularOps_DDRM.descendingOrder(null, false, W, V_t, true);
// strip off unneeded components and find the basis
V_t.reshape(numComponents, mean.Length, true);
}
/**
* <p>
* Computes the induced p = 2 matrix norm, which is the largest singular value.
* </p>
*
* @param A Matrix. Not modified.
* @return The norm.
*/
public static double inducedP2(DMatrixRMaj A)
{
SingularValueDecomposition_F64 <DMatrixRMaj> svd =
DecompositionFactory_DDRM.svd(A.numRows, A.numCols, false, false, true);
if (!svd.decompose(A))
{
throw new InvalidOperationException("Decomposition failed");
}
double[] singularValues = svd.getSingularValues();
// the largest singular value is the induced p2 norm
return(UtilEjml.max(singularValues, 0, singularValues.Length));
}
/**
* Computes the nullity of a matrix using the specified tolerance.
*
* @param A Matrix whose rank is to be calculated. Not modified.
* @param threshold The numerical threshold used to determine a singular value.
* @return The matrix's nullity.
*/
public static int nullity(DMatrixRMaj A, double threshold)
{
SingularValueDecomposition_F64 <DMatrixRMaj> svd =
DecompositionFactory_DDRM.svd(A.numRows, A.numCols, false, false, true);
if (svd.inputModified())
{
A = (DMatrixRMaj)A.copy();
}
if (!svd.decompose(A))
{
throw new InvalidOperationException("Decomposition failed");
}
return(SingularOps_DDRM.nullity(svd, threshold));
}
public SimpleEVD(T mat)
{
this.mat = mat;
this.is64 = mat is DMatrixRMaj;
if (is64)
{
eig = (EigenDecomposition <T>)DecompositionFactory_DDRM.eig(mat.getNumCols(), true);
}
else
{
eig = (EigenDecomposition <T>)DecompositionFactory_FDRM.eig(mat.getNumCols(), true);
}
if (!eig.decompose((T)mat))
{
throw new InvalidOperationException("Eigenvalue Decomposition failed");
}
}
/**
* Checks to see if the rows of the provided matrix are linearly independent.
*
* @param A Matrix whose rows are being tested for linear independence.
* @return true if linearly independent and false otherwise.
*/
public static bool isRowsLinearIndependent(DMatrixRMaj A)
{
// LU decomposition
LUDecomposition <DMatrixRMaj> lu = DecompositionFactory_DDRM.lu(A.numRows, A.numCols);
if (lu.inputModified())
{
A = (DMatrixRMaj)A.copy();
}
if (!lu.decompose(A))
{
throw new InvalidOperationException("Decompositon failed?");
}
// if they are linearly independent it should not be singular
return(!lu.isSingular());
}
public SimpleSVD(Matrix mat, bool compact)
{
this.mat = mat;
this.is64 = mat is DMatrixRMaj;
if (is64)
{
DMatrixRMaj m = (DMatrixRMaj)mat;
svd = (SingularValueDecomposition <T>)DecompositionFactory_DDRM.svd(m.numRows, m.numCols, true, true, compact);
}
else
{
FMatrixRMaj m = (FMatrixRMaj)mat;
svd = (SingularValueDecomposition <T>)DecompositionFactory_FDRM.svd(m.numRows, m.numCols, true, true, compact);
}
if (!svd.decompose((T)mat))
{
throw new InvalidOperationException("Decomposition failed");
}
U = SimpleMatrix <T> .wrap(svd.getU(null, false));
W = SimpleMatrix <T> .wrap(svd.getW(null));
V = SimpleMatrix <T> .wrap(svd.getV(null, false));
// order singular values from largest to smallest
if (is64)
{
var um = U.getMatrix() as DMatrixRMaj;
var wm = W.getMatrix() as DMatrixRMaj;
var vm = V.getMatrix() as DMatrixRMaj;
SingularOps_DDRM.descendingOrder(um, false, wm, vm, false);
tol = SingularOps_DDRM.singularThreshold((SingularValueDecomposition_F64 <DMatrixRMaj>)svd);
}
else
{
var um = U.getMatrix() as FMatrixRMaj;
var wm = W.getMatrix() as FMatrixRMaj;
var vm = V.getMatrix() as FMatrixRMaj;
SingularOps_FDRM.descendingOrder(um, false, wm, vm, false);
tol = SingularOps_FDRM.singularThreshold((SingularValueDecomposition_F32 <FMatrixRMaj>)svd);
}
}
public SymmetricQRAlgorithmDecomposition_DDRM(bool computeVectors)
: this(DecompositionFactory_DDRM.tridiagonal(0), computeVectors)
{
}
/** Revises the CMA-ES distribution to reflect the current fitness results in the provided subpopulation. */
public void UpdateDistribution(IEvolutionState state, Subpopulation subpop)
{
// % Sort by fitness and compute weighted mean into xmean
// [arfitness, arindex] = sort(arfitness); % minimization
// xmean = arx(:,arindex(1:mu))*weights; % recombination % Eq.39
// counteval += lambda;
// only need partial sort?
((List <Individual>)subpop.Individuals).Sort();
SimpleMatrixD artmp = new SimpleMatrixD(GenomeSize, mu);
SimpleMatrixD xold = xmean;
xmean = new SimpleMatrixD(GenomeSize, 1);
for (int i = 0; i < mu; i++)
{
DoubleVectorIndividual dvind = (DoubleVectorIndividual)subpop.Individuals[i];
// won't modify the genome
SimpleMatrixD arz = new SimpleMatrixD(GenomeSize, 1, true, dvind.genome);
arz = (arz.minus(xold).divide(sigma));
for (int j = 0; j < GenomeSize; j++)
{
xmean.set(j, 0, xmean.get(j, 0) + weights[i] * dvind.genome[j]);
artmp.set(j, i, arz.get(j, 0));
}
}
// % Cumulation: Update evolution paths
SimpleMatrixD y = xmean.minus(xold).divide(sigma);
SimpleMatrixD bz = invsqrtC.mult(y);
SimpleMatrixD bz_scaled = bz.scale(Math.Sqrt(cs * (2.0 - cs) * mueff));
ps = ps.scale(1.0 - cs).plus(bz_scaled);
double h_sigma_value =
((ps.dot(ps) / (1.0 - Math.Pow(1.0 - cs, 2.0 * (state.Generation + 1)))) / GenomeSize);
int hsig = (h_sigma_value < (2.0 + (4.0 / (GenomeSize + 1)))) ? 1 : 0;
SimpleMatrixD y_scaled = y.scale(hsig * Math.Sqrt(cc * (2.0 - cc) * mueff));
pc = pc.scale(1.0 - cc).plus(y_scaled);
// % Adapt covariance matrix C
c = c.scale(1.0 - c1 - cmu);
c = c.plus(pc.mult(pc.transpose()).plus(c.scale((1.0 - hsig) * cc * (2.0 - cc))).scale(c1));
c = c.plus((artmp.mult(SimpleMatrixD.diag(weights).mult(artmp.transpose()))).scale(cmu));
// % Adapt step-size sigma
sigma = sigma * Math.Exp((cs / damps) * (ps.normF() / chiN - 1.0));
// % Update B and D from C
if ((state.Generation - lastEigenDecompositionGeneration) > 1.0 / ((c1 + cmu) * GenomeSize * 10.0))
{
lastEigenDecompositionGeneration = state.Generation;
// make sure the matrix is symmetric (it should be already)
// not sure if this is necessary
for (int i = 0; i < GenomeSize; i++)
{
for (int j = 0; j < i; j++)
{
c.set(j, i, c.get(i, j));
}
}
// this copy gets modified by the decomposition
DMatrixRMaj copy = c.copy().getMatrix();
EigenDecomposition <DMatrixRMaj> eig = DecompositionFactory_DDRM.eig(GenomeSize, true, true);
if (eig.decompose(copy))
{
SimpleMatrixD dinv = new SimpleMatrixD(GenomeSize, GenomeSize);
for (int i = 0; i < GenomeSize; i++)
{
double eigrt = Math.Sqrt(eig.getEigenValue(i).real);
d.set(i, i, eigrt);
dinv.set(i, i, 1 / eigrt);
CommonOps_DDRM.insert(eig.getEigenVector(i), b.getMatrix(), 0, i);
}
invsqrtC = b.mult(dinv.mult(b.transpose()));
CommonOps_DDRM.mult(b.getMatrix(), d.getMatrix(), bd);
}
else
{
state.Output.Fatal("CMA-ES eigendecomposition failed. ");
}
}
CommonOps_DDRM.scale(sigma, bd, sbd);
// % Break, if fitness is good enough or condition exceeds 1e14, better termination methods are advisable
// if arfitness(1) <= stopfitness || max(D) > 1e7 * min(D)
// break;
// end
if (useAltTermination && CommonOps_DDRM.elementMax(d.diag().getMatrix()) >
1e7 * CommonOps_DDRM.elementMin(d.diag().getMatrix()))
{
state.Evaluator.SetRunCompleted("CMAESSpecies: Stopped because matrix condition exceeded limit.");
}
}
public override void Setup(IEvolutionState state, IParameter paramBase)
{
base.Setup(state, paramBase);
IMersenneTwister random = state.Random[0];
IParameter def = DefaultBase;
IParameter subpopBase = paramBase.Pop();
IParameter subpopDefaultBase = ECDefaults.ParamBase.Push(Subpopulation.P_SUBPOPULATION);
if (!state.Parameters.ParameterExists(paramBase.Push(P_SIGMA), def.Push(P_SIGMA)))
{
state.Output.Message("CMA-ES sigma was not provided, defaulting to 1.0");
sigma = 1.0;
}
else
{
sigma = state.Parameters.GetDouble(paramBase.Push(P_SIGMA), def.Push(P_SIGMA), 0.0);
if (sigma <= 0)
{
state.Output.Fatal("If CMA-ES sigma is provided, it must be > 0.0", paramBase.Push(P_SIGMA),
def.Push(P_SIGMA));
}
}
double[] cvals = new double[GenomeSize];
string covarianceInitialization =
state.Parameters.GetStringWithDefault(paramBase.Push(P_COVARIANCE), def.Push(P_COVARIANCE), V_IDENTITY);
string covs = "Initial Covariance: <";
for (int i = 0; i < GenomeSize; i++)
{
if (i > 0)
{
covs += ", ";
}
if (covarianceInitialization.Equals(V_SCALED))
{
cvals[i] = (MaxGenes[i] - MinGenes[i]);
}
else if (covarianceInitialization.Equals(V_IDENTITY))
{
cvals[i] = 1.0;
}
else
{
state.Output.Fatal("Invalid covariance initialization type " + covarianceInitialization,
paramBase.Push(P_COVARIANCE), def.Push(P_COVARIANCE));
}
// cvals is standard deviations, so we change them to variances now
cvals[i] *= cvals[i];
covs += cvals[i];
}
state.Output.Message(covs + ">");
// set myself up and define my initial distribution here
int n = GenomeSize;
b = SimpleMatrixD.identity(n);
c = new SimpleMatrixD(CommonOps_DDRM.diag(cvals));
d = SimpleMatrixD.identity(n);
bd = CommonOps_DDRM.identity(n, n);
sbd = CommonOps_DDRM.identity(n, n);
invsqrtC = SimpleMatrixD.identity(n);
// Here we do one FIRST round of eigendecomposition, because newIndividual needs
// a valid version of sbd. If c is initially the identity matrix (and sigma = 1),
// then sbd is too, and we're done. But if c is scaled in any way, we need to compute
// the proper value of sbd. Along the way we'll wind up computing b, d, bd, and invsqrtC
EigenDecomposition <DMatrixRMaj> eig = DecompositionFactory_DDRM.eig(GenomeSize, true, true);
if (eig.decompose(c.copy().getMatrix()))
{
SimpleMatrixD dinv = new SimpleMatrixD(GenomeSize, GenomeSize);
for (int i = 0; i < GenomeSize; i++)
{
double eigrt = Math.Sqrt(eig.getEigenValue(i).real);
d.set(i, i, eigrt);
dinv.set(i, i, 1 / eigrt);
CommonOps_DDRM.insert(eig.getEigenVector(i), b.getMatrix(), 0, i);
}
invsqrtC = b.mult(dinv.mult(b.transpose()));
CommonOps_DDRM.mult(b.getMatrix(), d.getMatrix(), bd);
}
else
{
state.Output.Fatal("CMA-ES eigendecomposition failed. ");
}
CommonOps_DDRM.scale(sigma, bd, sbd);
// End FIRST round of eigendecomposition
// Initialize dynamic (internal) strategy parameters and constants
pc = new SimpleMatrixD(n, 1);
ps = new SimpleMatrixD(n, 1); // evolution paths for C and sigma
chiN = Math.Sqrt(n) *
(1.0 - 1.0 / (4.0 * n) + 1.0 / (21.0 * n * n)); // expectation of ||N(0,I)|| == norm(randn(N,1))
xmean = new SimpleMatrixD(GenomeSize, 1);
bool meanSpecified = false;
string val = state.Parameters.GetString(paramBase.Push(P_MEAN), def.Push(P_MEAN));
if (val != null)
{
meanSpecified = true;
if (val.Equals(V_CENTER))
{
for (int i = 0; i < GenomeSize; i++)
{
xmean.set(i, 0, (MaxGenes[i] + MinGenes[i]) / 2.0);
}
}
else if (val.Equals(V_ZERO))
{
for (int i = 0; i < GenomeSize; i++)
{
xmean.set(i, 0, 0); // it is this anyway
}
}
else if (val.Equals(V_RANDOM))
{
for (int i = 0; i < GenomeSize; i++)
{
xmean.set(i, 0,
state.Random[0].NextDouble(true, true) * (MaxGenes[i] - MinGenes[i]) + MinGenes[i]);
}
}
else
{
state.Output.Fatal("Unknown mean value specified: " + val, paramBase.Push(P_MEAN), def.Push(P_MEAN));
}
}
else
{
state.Output.Fatal("No default mean value specified. Loading full mean from parameters.",
paramBase.Push(P_MEAN), def.Push(P_MEAN));
}
bool nonDefaultMeanSpecified = false;
for (int i = 0; i < GenomeSize; i++)
{
double m_i = 0;
try
{
m_i = state.Parameters.GetDouble(paramBase.Push(P_MEAN).Push("" + i), def.Push(P_MEAN).Push("" + i));
xmean.set(i, 0, m_i);
nonDefaultMeanSpecified = true;
}
catch (FormatException e)
{
if (!meanSpecified)
{
state.Output.Error(
"No default mean value was specified, but CMA-ES mean index " + i +
" is missing or not a number.", paramBase.Push(P_MEAN).Push("" + i),
def.Push(P_MEAN).Push("" + i));
}
}
}
state.Output.ExitIfErrors();
if (nonDefaultMeanSpecified && meanSpecified)
{
state.Output.Warning("A default mean value was specified, but certain mean values were overridden.");
}
string mes = "Initial Mean: <";
for (int i = 0; i < GenomeSize - 1; i++)
{
mes = mes + xmean.get(i, 0) + ", ";
}
mes = mes + xmean.get(GenomeSize - 1, 0) + ">";
state.Output.Message(mes);
if (!state.Parameters.ParameterExists(paramBase.Push(P_LAMBDA), def.Push(P_LAMBDA)))
{
lambda = 4 + (int)Math.Floor(3 * Math.Log(n));
}
else
{
lambda = state.Parameters.GetInt(paramBase.Push(P_LAMBDA), def.Push(P_LAMBDA), 1);
if (lambda <= 0)
{
state.Output.Fatal("If the CMA-ES lambda parameter is provided, it must be a valid integer > 0",
paramBase.Push(P_LAMBDA), def.Push(P_LAMBDA));
}
}
if (!state.Parameters.ParameterExists(paramBase.Push(P_MU), def.Push(P_MU)))
{
mu = (int)(Math.Floor(lambda / 2.0));
}
else
{
mu = state.Parameters.GetInt(paramBase.Push(P_MU), def.Push(P_MU), 1);
if (mu <= 0)
{
state.Output.Fatal("If the CMA-ES mu parameter is provided, it must be a valid integer > 0",
paramBase.Push(P_MU), def.Push(P_MU));
}
}
if (mu > lambda) // uh oh
{
state.Output.Fatal("CMA-ES mu must be <= lambda. Presently mu=" + mu + " and lambda=" + lambda);
}
weights = new double[mu];
bool weightsSpecified = false;
for (int i = 0; i < mu; i++)
{
if (state.Parameters.ParameterExists(paramBase.Push(P_WEIGHTS).Push("" + i), def.Push(P_WEIGHTS).Push("" + i)))
{
state.Output.Message("CMA-ES weight index " + i +
" specified. Loading all weights from parameters.");
weightsSpecified = true;
break;
}
}
if (weightsSpecified)
{
for (int i = 0; i < mu; i++)
{
double m_i = 0;
try
{
weights[i] = state.Parameters.GetDouble(paramBase.Push(P_WEIGHTS).Push("" + i),
def.Push(P_WEIGHTS).Push("" + i));
}
catch (FormatException e)
{
state.Output.Error("CMA-ES weight index " + i + " missing or not a number.",
paramBase.Push(P_WEIGHTS).Push("" + i), def.Push(P_WEIGHTS).Push("" + i));
}
}
state.Output.ExitIfErrors();
}
else
{
for (int i = 0; i < mu; i++)
{
weights[i] = Math.Log((lambda + 1.0) / (2.0 * (i + 1)));
}
}
// normalize
double sum = 0.0;
for (int i = 0; i < mu; i++)
{
sum += weights[i];
}
for (int i = 0; i < mu; i++)
{
weights[i] /= sum;
}
// compute mueff
double sumSqr = 0.0;
for (int i = 0; i < mu; i++)
{
sumSqr += weights[i] * weights[i];
}
mueff = 1.0 / sumSqr;
mes = "Weights: <";
for (int i = 0; i < weights.Length - 1; i++)
{
mes = mes + weights[i] + ", ";
}
mes = mes + (weights.Length - 1) + ">";
state.Output.Message(mes);
useAltTermination = state.Parameters.GetBoolean(paramBase.Push(P_ALTERNATIVE_TERMINATION),
def.Push(P_ALTERNATIVE_TERMINATION), false);
useAltGenerator = state.Parameters.GetBoolean(paramBase.Push(P_ALTERNATIVE_GENERATOR),
def.Push(P_ALTERNATIVE_GENERATOR), false);
altGeneratorTries = state.Parameters.GetIntWithDefault(paramBase.Push(P_ALTERNATIVE_GENERATOR_TRIES),
def.Push(P_ALTERNATIVE_GENERATOR_TRIES), DEFAULT_ALT_GENERATOR_TRIES);
if (altGeneratorTries < 1)
{
state.Output.Fatal(
"If specified (the default is " + DEFAULT_ALT_GENERATOR_TRIES +
"), alt-generation-tries must be >= 1",
paramBase.Push(P_ALTERNATIVE_GENERATOR_TRIES), def.Push(P_ALTERNATIVE_GENERATOR_TRIES));
}
if (!state.Parameters.ParameterExists(paramBase.Push(P_CC), def.Push(P_CC)))
{
cc = (4.0 + mueff / n) / (n + 4.0 + 2.0 * mueff / n); // time constant for cumulation for C
}
else
{
cc = state.Parameters.GetDoubleWithMax(paramBase.Push(P_CC), def.Push(P_CC), 0.0, 1.0);
if (cc < 0.0)
{
state.Output.Fatal(
"If the CMA-ES cc parameter is provided, it must be a valid number in the range [0,1]",
paramBase.Push(P_CC), def.Push(P_CC));
}
}
if (!state.Parameters.ParameterExists(paramBase.Push(P_CS), def.Push(P_CS)))
{
cs = (mueff + 2.0) / (n + mueff + 5.0); // t-const for cumulation for sigma control
}
else
{
cs = state.Parameters.GetDoubleWithMax(paramBase.Push(P_CS), def.Push(P_CS), 0.0, 1.0);
if (cs < 0.0)
{
state.Output.Fatal(
"If the CMA-ES cs parameter is provided, it must be a valid number in the range [0,1]",
paramBase.Push(P_CS), def.Push(P_CS));
}
}
if (!state.Parameters.ParameterExists(paramBase.Push(P_C1), def.Push(P_C1)))
{
c1 = 2.0 / ((n + 1.3) * (n + 1.3) + mueff); // learning rate for rank-one update of C
}
else
{
c1 = state.Parameters.GetDouble(paramBase.Push(P_C1), def.Push(P_C1), 0.0);
if (c1 < 0)
{
state.Output.Fatal("If the CMA-ES c1 parameter is provided, it must be a valid number >= 0.0",
paramBase.Push(P_C1), def.Push(P_C1));
}
}
if (!state.Parameters.ParameterExists(paramBase.Push(P_CMU), def.Push(P_CMU)))
{
cmu = Math.Min(1.0 - c1, 2.0 * (mueff - 2.0 + 1.0 / mueff) / ((n + 2.0) * (n + 2.0) + mueff));
}
else
{
cmu = state.Parameters.GetDouble(paramBase.Push(P_CMU), def.Push(P_CMU), 0.0);
if (cmu < 0)
{
state.Output.Fatal("If the CMA-ES cmu parameter is provided, it must be a valid number >= 0.0",
paramBase.Push(P_CMU), def.Push(P_CMU));
}
}
if (c1 > (1 - cmu)) // uh oh
{
state.Output.Fatal("CMA-ES c1 must be <= 1 - cmu. You are using c1=" + c1 + " and cmu=" + cmu);
}
if (cmu > (1 - c1)) // uh oh
{
state.Output.Fatal("CMA-ES cmu must be <= 1 - c1. You are using cmu=" + cmu + " and c1=" + c1);
}
if (!state.Parameters.ParameterExists(paramBase.Push(P_DAMPS), def.Push(P_DAMPS)))
{
damps = 1.0 + 2.0 * Math.Max(0.0, Math.Sqrt((mueff - 1.0) / (n + 1.0)) - 1.0) + cs; // damping for sigma
}
else
{
damps = state.Parameters.GetDouble(paramBase.Push(P_DAMPS), def.Push(P_DAMPS), 0.0);
if (damps <= 0)
{
state.Output.Fatal("If the CMA-ES damps parameter is provided, it must be a valid number > 0.0",
paramBase.Push(P_DAMPS), def.Push(P_DAMPS));
}
}
double damps_min = 0.5;
double damps_max = 2.0;
if (damps > damps_max || damps < damps_min)
{
state.Output.Warning("CMA-ES damps ought to be close to 1. You are using damps = " + damps);
}
state.Output.Message("lambda: " + lambda);
state.Output.Message("mu: " + mu);
state.Output.Message("mueff: " + mueff);
state.Output.Message("cmu: " + cmu);
state.Output.Message("c1: " + c1);
state.Output.Message("cc: " + cc);
state.Output.Message("cs: " + cs);
state.Output.Message("damps: " + damps);
}
/**
* Creates a new solver targeted at the specified matrix size.
*
* @param maxRows The expected largest matrix it might have to process. Can be larger.
* @param maxCols The expected largest matrix it might have to process. Can be larger.
*/
public SolvePseudoInverseSvd_DDRM(int maxRows, int maxCols)
{
svd = DecompositionFactory_DDRM.svd(maxRows, maxCols, true, true, true);
}
