Object invoke(String methodName, Object... parameters)
throws IllegalAccessException, InvocationTargetException {
String mid = methodId(methodName, parameters.length);
List<Method> methods = methodCache.get(mid);
Method method = null;
if (methods == null) {
throw new IllegalAccessException("No method " + mid); // NOI18N
}
if (methods.size() == 1) {
method = methods.get(0);
} else {
Class[] parClasses = new Class[parameters.length];
for (int i = 0; i < parameters.length; i++) {
Class cl = parameters[i].getClass();
if (primitiveTypes.containsKey(cl)) {
cl = primitiveTypes.get(cl);
}
parClasses[i] = cl;
}
for (Method m : methods) {
if (Arrays.deepEquals(m.getParameterTypes(), parClasses)) {
method = m;
break;
}
}
}
if (method == null) {
throw new IllegalArgumentException(
instance + " " + methodName + " " + Arrays.toString(parameters));
}
return method.invoke(instance, parameters);
}
/**
* Provides a static, single instance of the application context. This method can be called
* repeatedly.
*
* <p>If the configuration requested differs from one used previously, then the previously-created
* context is shut down.
*
* @return Returns an application context for the given configuration
*/
public static synchronized ApplicationContext getApplicationContext(
String[] configLocations, String[] classLocations) throws IOException {
if (configLocations == null) {
throw new IllegalArgumentException("configLocations argument is mandatory.");
}
if (usedConfiguration != null
&& Arrays.deepEquals(configLocations, usedConfiguration)
&& classLocations != null
&& Arrays.deepEquals(classLocations, usedClassLocations)) {
// The configuration was used to create the current context
return instance;
}
// The config has changed so close the current context (if any)
closeApplicationContext();
if (useLazyLoading || noAutoStart) {
instance = new VariableFeatureClassPathXmlApplicationContext(configLocations);
} else {
instance = new ClassPathXmlApplicationContext(configLocations, false);
}
if (classLocations != null) {
ClassLoader classLoader = buildClassLoader(classLocations);
instance.setClassLoader(classLoader);
}
instance.refresh();
usedConfiguration = configLocations;
usedClassLocations = classLocations;
return instance;
}
@Override
public boolean equals(final Object o) {
if (o == this) {
return true;
}
if (o == null) {
return false;
}
if (o instanceof ImmutableOffsetMap) {
final ImmutableOffsetMap<?, ?> om = (ImmutableOffsetMap<?, ?>) o;
if (newKeys.isEmpty()
&& offsets == om.offsets()
&& Arrays.deepEquals(objects, om.objects())) {
return true;
}
} else if (o instanceof MutableOffsetMap) {
final MutableOffsetMap<?, ?> om = (MutableOffsetMap<?, ?>) o;
if (offsets == om.offsets
&& Arrays.deepEquals(objects, om.objects)
&& newKeys.equals(om.newKeys)) {
return true;
}
} else if (o instanceof Map) {
final Map<?, ?> om = (Map<?, ?>) o;
// Size and key sets have to match
if (size() != om.size() || !keySet().equals(om.keySet())) {
return false;
}
try {
// Ensure all newKeys are present. Note newKeys is guaranteed to
// not contain null value.
for (Entry<K, V> e : newKeys.entrySet()) {
if (!e.getValue().equals(om.get(e.getKey()))) {
return false;
}
}
// Ensure all objects are present
for (Entry<K, Integer> e : offsets.entrySet()) {
final Object obj = objects[e.getValue()];
if (!NO_VALUE.equals(obj)) {
final V v = objectToValue(e.getKey(), obj);
if (!v.equals(om.get(e.getKey()))) {
return false;
}
}
}
} catch (ClassCastException e) {
// Can be thrown by om.get() and indicate we have incompatible key types
return false;
}
return true;
}
return false;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
if (!super.equals(o)) return false;
final A a = (A) o;
if (a7 != a.a7) return false;
if (a8 != a.a8) return false;
if (a9 != a.a9) return false;
if (a10 != a.a10) return false;
if (Float.compare(a.a11, a11) != 0) return false;
if (Double.compare(a.a12, a12) != 0) return false;
// Probably incorrect - comparing Object[] arrays with Arrays.equals
if (!Arrays.equals(a1, a.a1)) return false;
if (!Arrays.deepEquals(a2, a.a2)) return false;
// Probably incorrect - comparing Object[] arrays with Arrays.equals
if (!Arrays.equals(a3, a.a3)) return false;
if (!Arrays.deepEquals(a4, a.a4)) return false;
if (!Arrays.equals(a5, a.a5)) return false;
if (!Arrays.deepEquals(a6, a.a6)) return false;
if (!a13.equals(a.a13)) return false;
if (!a14.equals(a.a14)) return false;
return true;
}
@Override
public boolean deepEqual(IAObject obj) {
if (!(obj instanceof ARecordType)) {
return false;
}
ARecordType rt = (ARecordType) obj;
return (isOpen == rt.isOpen)
&& Arrays.deepEquals(fieldNames, rt.fieldNames)
&& Arrays.deepEquals(fieldTypes, rt.fieldTypes);
}
public Object invokeMethod(String name, String[] parameterTypes, Object[] arguments)
throws Throwable {
if (_methodName28.equals(name) && Arrays.deepEquals(_methodParameterTypes28, parameterTypes)) {
return TableFromAnotherDataSourceServiceUtil.getBeanIdentifier();
}
if (_methodName29.equals(name) && Arrays.deepEquals(_methodParameterTypes29, parameterTypes)) {
TableFromAnotherDataSourceServiceUtil.setBeanIdentifier((java.lang.String) arguments[0]);
}
throw new UnsupportedOperationException();
}
public Object invokeMethod(String name, String[] parameterTypes, Object[] arguments)
throws Throwable {
if (_methodName22.equals(name) && Arrays.deepEquals(_methodParameterTypes22, parameterTypes)) {
return CalEventAttendeeServiceUtil.getBeanIdentifier();
}
if (_methodName23.equals(name) && Arrays.deepEquals(_methodParameterTypes23, parameterTypes)) {
CalEventAttendeeServiceUtil.setBeanIdentifier((java.lang.String) arguments[0]);
}
throw new UnsupportedOperationException();
}
public Object invokeMethod(String name, String[] parameterTypes, Object[] arguments)
throws Throwable {
if (_methodName92.equals(name) && Arrays.deepEquals(_methodParameterTypes92, parameterTypes)) {
return UserAssignmentServiceUtil.getBeanIdentifier();
}
if (_methodName93.equals(name) && Arrays.deepEquals(_methodParameterTypes93, parameterTypes)) {
UserAssignmentServiceUtil.setBeanIdentifier((java.lang.String) arguments[0]);
return null;
}
throw new UnsupportedOperationException();
}
public Object invokeMethod(String name, String[] parameterTypes, Object[] arguments)
throws Throwable {
if (_methodName18.equals(name) && Arrays.deepEquals(_methodParameterTypes18, parameterTypes)) {
return GlobalInformationServiceUtil.getBeanIdentifier();
}
if (_methodName19.equals(name) && Arrays.deepEquals(_methodParameterTypes19, parameterTypes)) {
GlobalInformationServiceUtil.setBeanIdentifier((java.lang.String) arguments[0]);
return null;
}
throw new UnsupportedOperationException();
}
public Object invokeMethod(String name, String[] parameterTypes, Object[] arguments)
throws Throwable {
if (_methodName246.equals(name)
&& Arrays.deepEquals(_methodParameterTypes246, parameterTypes)) {
return ContestTeamMemberServiceUtil.getBeanIdentifier();
}
if (_methodName247.equals(name)
&& Arrays.deepEquals(_methodParameterTypes247, parameterTypes)) {
ContestTeamMemberServiceUtil.setBeanIdentifier((java.lang.String) arguments[0]);
return null;
}
throw new UnsupportedOperationException();
}
public void readModel(int n, int k, double[][] points, int[] weight, DistanceMeasure measure)
throws OperatorException {
if (modelInput.isConnected()) {
KNNCollectionModel input;
input = modelInput.getData(KNNCollectionModel.class);
knnCollection = input.get();
newCollection = false;
if (k > knnCollection.getK()
|| !Arrays.deepEquals(knnCollection.getPoints(), points)
|| !measure.getClass().toString().equals(input.measure.getClass().toString())) {
if (k > knnCollection.getK()) {
this.logNote("Model at input port can not be used (k too small).");
} else {
this.logNote("Model at input port can not be used (Model andExampleSet not matching).");
}
knnCollection = new KNNCollection(n, k, points, weight);
newCollection = true;
} else {
this.logNote(" Model at input port used for speeding up the operator.");
}
if (k < knnCollection.getK()) {
knnCollection = KNNCollection.clone(knnCollection);
knnCollection.shrink(knnCollection.getK() - k);
}
} else {
knnCollection = new KNNCollection(n, k, points, weight);
newCollection = true;
}
}
/**
* Check whether the indicated pattern is valid according to the mirror method.
*
* @param squares The pattern to investigate.
* @return True if the pattern is valid according to this approach.
*/
public static boolean validByMirroring(int[][] squares) {
int[][] original = squares;
int[][] originalRight90 = rotateRight(original);
int[][] originalRight180 = rotateRight(originalRight90); // = horizontally mirrored
int[][] originalRight270 = rotateRight(originalRight180); // = left 90
int[][] mirrored = mirrorVertically(original);
int[][] mirroredRight90 = rotateRight(mirrored);
int[][] mirroredRight180 = rotateRight(mirroredRight90); // = horizontally mirrored
int[][] mirroredRight270 = rotateRight(mirroredRight180); // = left 90
int[][][] patterns = {
original,
originalRight90,
originalRight180,
originalRight270,
mirrored,
mirroredRight90,
mirroredRight180,
mirroredRight270
};
for (int i = 0; i < patterns.length; i++) {
for (int j = i; j < patterns.length; j++) {
if (j > i && Arrays.deepEquals(patterns[i], patterns[j])) {
return false;
}
}
}
return true;
}
/**
* Tests the computation of DRQA line length histograms on a toy example that covers definite and
* indefinite lines of length 1 and length >1.
*/
public void testHistogramComputation() {
DRQA.conditional_ww_limit = 10;
DRQA drqa = new DRQA(trajectory, eps);
// compare the computed histograms (diagonal, vertical, ...) against the correct histograms
assertArrayEquals(new long[] {0, 7, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, drqa.l_hist);
assertArrayEquals(new long[] {0, 18, 5, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, drqa.v_hist);
assertArrayEquals(new long[] {0, 0, 8, 3, 3, 3, 0, 5, 0, 0, 0, 0, 0, 0, 0}, drqa.w_hist);
assertArrayEquals(new long[] {0, 5, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, drqa.r_hist);
assertArrayEquals(
new long[] {0, 6, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}, drqa.l_hist_indefinite);
assertArrayEquals(
new long[] {0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, drqa.v_hist_indefinite);
assertArrayEquals(
new long[] {0, 3, 6, 3, 3, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0}, drqa.w_hist_indefinite);
assertArrayEquals(
new long[] {0, 6, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0}, drqa.r_hist_indefinite);
double[][] expectedCRT =
new double[][] {
new double[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
new double[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
new double[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
new double[] {0, 0, 0, 0, 3, 0, 0, 0, 0, 0},
new double[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
new double[] {0, 0, 3, 0, 0, 0, 0, 0, 0, 0},
new double[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
new double[] {0, 0, 5, 0, 0, 0, 0, 0, 0, 0},
new double[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
new double[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
};
assertTrue(Arrays.deepEquals(expectedCRT, drqa.conditional_ww.toArray()));
}
@Override
public boolean equals(Object obj) {
return obj != null
&& getClass() == obj.getClass()
&& this.number == ((DefaultBoard) obj).number
&& Arrays.deepEquals(this.board, ((DefaultBoard) obj).board);
}
@Test(dataProvider = "onCommandLongTests")
public void executeOnCommandLongTest(
String cmdMessage, OnCommandLong command, String[][] expectedArgs) throws Exception {
// Build the CommandEvent
CommandEvent event =
new CommandEvent(
command,
new MessageEvent(bot, null, null, cmdMessage),
null,
null,
cmdMessage,
"?testCommand",
hook.getArgs(cmdMessage));
// Execute and verify values
String returned = hook.executeOnCommandLong(event);
assertEquals(returned, "Success", "onCommandLong doesn't return expected value");
log.debug("Current command: " + command.getName());
logMultiArray(expectedArgs, "Expected args");
logMultiArray(command.getArgs(), "Given args");
assertTrue(
Arrays.deepEquals(command.getArgs(), expectedArgs),
"Command test " + command.getName() + " args don't equal");
}
/** Instead of only testing onCommandLong, test feeding into onMessage */
@Test(dataProvider = "onCommandLongTests")
public void executeTest(String cmdMessage, OnCommandLong command, String[][] expectedArgs)
throws Exception {
// Remove the prefix
cmdMessage = cmdMessage.substring(1);
// Build the messageEvent
final StringBuilder response = new StringBuilder();
MessageEvent messageEvent =
new MessageEvent(bot, channel, null, cmdMessage) {
@Override
public void respond(String commandResponse) {
if (commandResponse != null) response.append(commandResponse);
}
};
// Add our test listener
controller.getHookManager().addHook(command);
// Feed into onMessage
log.trace("Sending message " + cmdMessage);
hook.execute(messageEvent, channel, user, cmdMessage);
// Verify the results
assertEquals(
response.toString(),
"Success",
"onCommandLong in test " + command.getName() + " doesn't return expected value");
assertTrue(
Arrays.deepEquals(command.getArgs(), expectedArgs),
"Command test " + command.getName() + " args don't equal");
// Remove it to cleanup
controller.getHookManager().removeHook(command);
}
/** @since 3.2.0 */
public static IMethod getMethod(
IType type, String methodName, String[] parameterTypes, boolean includeHierarchy) {
int index = methodName.indexOf('(');
if (index >= 0) {
methodName = methodName.substring(0, index);
}
try {
while (type != null) {
for (IMethod method : Introspector.getMethods(type)) {
if (method.getElementName().equals(methodName)
&& method.getParameterTypes().length == parameterTypes.length) {
String[] methodParameterTypes = getParameterTypesAsStringArray(method);
if (Arrays.deepEquals(parameterTypes, methodParameterTypes)) {
return method;
}
}
}
if (!includeHierarchy) break;
type = Introspector.getSuperType(type);
}
return Introspector.findMethod(
type, methodName, parameterTypes.length, Public.YES, Static.DONT_CARE);
} catch (JavaModelException e) {
}
return null;
}
@Test
public void ConstructorWithComplexNumberParametersWorkCorrect() {
ComplexMatrix2x2 matrix = (ComplexMatrix2x2) context.getBean("nonZeroMatrix2");
ComplexNumber cN = ComplexMatrix2x2Util.getComplexNumber(1, 2);
ComplexNumber[][] complexNumbers = new ComplexNumber[][] {{cN, cN}, {cN, cN}};
assertTrue(Arrays.deepEquals(matrix.getMatrix(), complexNumbers));
}
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (!(o instanceof ResultLogConfig)) return false;
final ResultLogConfig other = (ResultLogConfig) o;
return Arrays.deepEquals(toArray(), other.toArray());
}
/**
* JPASupport instances a and b are equals if either <strong>a == b</strong> or a and b have same
* </strong>{@link #key key} and class</strong>
*
* @param other
* @return true if equality condition above is verified
*/
@Override
public boolean equals(Object other) {
final Object key = this._key();
if (other == null) {
return false;
}
if (this == other) {
return true;
}
if (key == null) {
return false;
}
if (play.db.Model.class.isAssignableFrom(other.getClass()) && key.getClass().isArray()) {
Object otherKey = ((play.db.Model) other)._key();
if (otherKey.getClass().isArray()) {
return Arrays.deepEquals((Object[]) key, (Object[]) otherKey);
}
return false;
}
if (!this.getClass().isAssignableFrom(other.getClass())) {
return false;
}
return key.equals(((play.db.Model) other)._key());
}
private LineParser createDocDataLineReader(String line) {
String[] header;
String headIndicator = WriteLineDocTask.FIELDS_HEADER_INDICATOR + WriteLineDocTask.SEP;
if (line.startsWith(headIndicator)) {
header =
line.substring(headIndicator.length()).split(Character.toString(WriteLineDocTask.SEP));
skipHeaderLine = true; // mark to skip the header line when input file is reopened
} else {
header = WriteLineDocTask.DEFAULT_FIELDS;
}
// if a specific DocDataLineReader was configured, must respect it
String docDataLineReaderClassName = getConfig().get("line.parser", null);
if (docDataLineReaderClassName != null) {
try {
final Class<? extends LineParser> clazz =
Class.forName(docDataLineReaderClassName).asSubclass(LineParser.class);
Constructor<? extends LineParser> cnstr = clazz.getConstructor(String[].class);
return cnstr.newInstance((Object) header);
} catch (Exception e) {
throw new RuntimeException("Failed to instantiate " + docDataLineReaderClassName, e);
}
}
// if this the simple case,
if (Arrays.deepEquals(header, WriteLineDocTask.DEFAULT_FIELDS)) {
return new SimpleLineParser(header);
}
return new HeaderLineParser(header);
}
// @Test( expected = UnsupportedTypeException.class)
@Test()
public void ReadSparseTypeTest() throws NullPointerException, JavasciException {
assertTrue(sci.exec("W=sparse([1,2;4,5;3,10],[1,2,3]);"));
assertEquals(sci.getVariableType("W"), ScilabTypeEnum.sci_sparse);
ScilabSparse aFromScilab = (ScilabSparse) sci.get("W");
assertTrue(
aFromScilab.toString().equals("sparse([1, 2 ; 3, 10 ; 4, 5], [1.0 ; 3.0 ; 2.0], [4, 10])"));
assertTrue(sci.exec("AZE= " + aFromScilab.toString()));
ScilabSparse aFromScilab2 = (ScilabSparse) sci.get("AZE");
assertTrue(Arrays.deepEquals(aFromScilab.getFullRealPart(), aFromScilab2.getFullRealPart()));
ScilabSparse mySparse =
new ScilabSparse(
100,
100,
5,
new int[] {1, 1, 1, 1, 1},
new int[] {1, 25, 50, 75, 99},
new double[] {1.0, 2.0, 3.0, 4.0, 5.0});
// sci.put with a sparse is not yet functionnal
// assertTrue(sci.put("mySparse", mySparse));
// String ref="mySparseRef = sparse([1, 2 ; 2, 26 ; 3, 51 ; 4, 76 ; 5, 100], [1.0 ; 2.0 ;
// 3.0 ; 4.0 ; 5.0], [100, 100]);";
// sci.exec("isEqual=(mySparseRef==mySparse)");
// ScilabBoolean isEqual = (ScilabBoolean)sci.get("isEqual");
// System.out.println("isequal " +isEqual);
}
@Test
public void testOnlyOneWayMatrixMultiplication() {
int[][] a = {{1, 2, 3, 4}, {5, 6, 7, 8}};
int[][] b = {{1}, {-1}, {1}, {-1}};
int[][] expected = {{-2}, {-2}};
try {
boolean equal = Arrays.deepEquals(expected, Matrix.multiply(a, b));
assertTrue(equal);
} catch (MatrixDimensionMismatchException e) {
fail("The matrix multiplication should work for mismatched (but tennable) matrices.");
}
boolean thrown = false;
try {
Matrix.multiply(b, a);
fail(
"The matrix multiplication was successful. It should have thrown a dimension mismatch exception");
;
} catch (MatrixDimensionMismatchException expectedException) {
thrown = true;
}
assertTrue(thrown);
}
@Override
protected void init() {
if (validation != null && n_folds != 0)
throw new UnsupportedOperationException(
"Cannot specify a validation dataset and non-zero number of cross-validation folds.");
if (n_folds < 0)
throw new UnsupportedOperationException(
"The number of cross-validation folds must be >= 0.");
super.init();
xval_models = new Key[n_folds];
for (int i = 0; i < xval_models.length; ++i)
xval_models[i] = Key.make(dest().toString() + "_xval" + i);
int rIndex = 0;
for (int i = 0; i < source.vecs().length; i++)
if (source.vecs()[i] == response) {
rIndex = i;
break;
}
_responseName = source._names != null && rIndex >= 0 ? source._names[rIndex] : "response";
_train = selectVecs(source);
_names = new String[cols.length];
for (int i = 0; i < cols.length; i++) _names[i] = source._names[cols[i]];
// Compute source response domain
if (classification) _sourceResponseDomain = getVectorDomain(response);
// Is validation specified?
if (validation != null) {
// Extract a validation response
int idx = validation.find(source.names()[rIndex]);
if (idx == -1)
throw new IllegalArgumentException(
"Validation set does not have a response column called " + _responseName);
_validResponse = validation.vecs()[idx];
// Compute output confusion matrix domain for classification:
// - if validation dataset is specified then CM domain is union of train and validation
// response domains
// else it is only domain of response column.
if (classification) {
_validResponseDomain = getVectorDomain(_validResponse);
if (_validResponseDomain != null) {
_cmDomain = Utils.domainUnion(_sourceResponseDomain, _validResponseDomain);
if (!Arrays.deepEquals(_sourceResponseDomain, _validResponseDomain)) {
_fromModel2CM =
Model.getDomainMapping(
_cmDomain,
_sourceResponseDomain,
false); // transformation from model produced response ~> cmDomain
_fromValid2CM =
Model.getDomainMapping(
_cmDomain,
_validResponseDomain,
false); // transformation from validation response domain ~> cmDomain
}
} else _cmDomain = _sourceResponseDomain;
} /* end of if classification */
} else if (classification) _cmDomain = _sourceResponseDomain;
}
// Calcula si una matriz es AtinSimétrica. Es decir que coincidan su inversa con su transpuesta
public static boolean esAntiSimetrica(int[][] m) {
int[][] mi = Matriz.negativa(m);
int[][] mt = Matriz.transponer(m);
if (Arrays.deepEquals(mi, mt)) return true;
else return false;
}
/* (non-Javadoc)
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(Object obj) {
if (!(obj instanceof ParameterSet)) {
return false;
}
ParameterSet other = (ParameterSet) obj;
return Arrays.deepEquals(m_params, other.m_params);
}
@Override
public boolean myEquals(ExampleElement obj) {
if (obj == null || !(obj instanceof MultiplicationElement)) {
return false;
}
MultiplicationElement other = (MultiplicationElement) obj;
return Arrays.deepEquals(operands, other.operands);
}
@Override
public boolean equals(Object obj) {
if ((obj instanceof Tuple) == false) {
return false;
}
Tuple other = (Tuple) obj;
return Arrays.deepEquals(values, other.values);
}
@Test
public void defaultConstructorShouldWorkCorrect() {
ComplexMatrix2x2 matrix = (ComplexMatrix2x2) context.getBean("zeroMatrix");
ComplexNumber complexNumber = ComplexMatrix2x2Util.getComplexNumber(0, 0);
ComplexNumber[][] complexNumbers =
new ComplexNumber[][] {{complexNumber, complexNumber}, {complexNumber, complexNumber}};
assertTrue(Arrays.deepEquals(matrix.getMatrix(), complexNumbers));
}
@Test
public void addShouldWorkCorrect() {
ComplexMatrix2x2 matrix = (ComplexMatrix2x2) context.getBean("nonZeroMatrix3");
ComplexNumber cN1 = ComplexMatrix2x2Util.getComplexNumber(10, 2);
ComplexNumber cN2 = ComplexMatrix2x2Util.getComplexNumber(6, 8);
ComplexNumber[][] complexNumbers = new ComplexNumber[][] {{cN1, cN1}, {cN2, cN2}};
assertTrue(Arrays.deepEquals(matrix.add(matrix).getMatrix(), complexNumbers));
}
