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)); }