Diese Methode returned. Die eigentliche (obere) funktion wurde aus
rückwärtskompatibilität belassen. Diese Methode wird zB im
getTemplateVars der MultiCheckbox verwendet.
162302
public function returnFormField($vars)
    {
        extract($vars);
        $ret = '';
        if (isset($mask)) $ret .= '{' . $mask . '}';
        if (isset($preHtml)) { $ret .= $preHtml; }
        if (isset($html)) {
            $ret .= $html;
        } elseif (isset($items)) {
            foreach ($items as $i) {
                $ret .= $this->returnFormField($i);
            }
        } elseif (isset($component)) {
            $view = new Kwf_Component_Renderer();
            $ret .= $view->renderComponent($component);
        }
        if (isset($postHtml)) { $ret .= $postHtml; }
        if (isset($mask)) $ret .= '{/' . $mask . '}';
        return $ret;
    }
405186
public function get() {
    $__html = NULL;
    
    if ($this->validate()) {
    
      /* dies ersetzt variablen die durch das template verändert werden können: $$__varName */
      extract((array)$this->vars);
      
      $tpl = $this;

      /* get as String */
      try {
        ob_start();
        require $this->file;
        $__html = ob_get_contents();
        ob_end_clean();
      } catch (\Psc\Exception $e) {
        $e->setMessage(sprintf('in TPL(%s): %s',$this->getDisplayName(),$e->getMessage()));
        throw $e;
      }
  
      /* testen ob noch variablen übrig sind */
      //if (DEV) {
      //  $__matches = array();
      //  if (preg_match_all('/\{\$([a-zA-Z_0-9]*)\}/',$__html,$__matches,PREG_SET_ORDER) > 0) {
      //    foreach ($__matches as $__match) {
      //    //throw new Exception('in Template: '.$__fileName.' ist Variable "'.$__match[1].'" nicht definiert');
      //      trigger_error('in Template: '.$__fileName.' wird die Variable "'.$__match[1].'" nicht definiert (die von einem anderen Template benötigt wird)',E_USER_WARNING);
      //    }
      //  }
      //}
  
      if ($this->indent !== NULL) {
        $__html = S::indent($__html, $this->indent);
      }
    }

    return $__html;
  }
1226139
private Vector<Vector<HashMap<FuzzyAllenIntervalConstraint.Type, Double>>> createFuzzyCompleteNetwork(Constraint[] cns) {	
		
		if(subs != null){
			if(subs.size() > 0) 
				isSubGraph = true;
		}
		Constraint[] c = extractSubGraphCons(cns);
		
/*		if(isSubGraph){
			
			System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
			for (int i = 0; i < cns.length; i++) {
				System.out.println("cns: " + cns[i]);	
			}
			System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
			for (int i = 0; i < subs.size(); i++) {
				System.out.println("sb: " + subs.get(i));
			}
			System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
			for (int i = 0; i < c.length; i++) {
				System.out.println("c: " + c[i]);	
			}
		} //Iran
*/
		setNumVars(c);
		
		Vector<Vector<HashMap<FuzzyAllenIntervalConstraint.Type, Double>>> frelations = new Vector<Vector<HashMap<FuzzyAllenIntervalConstraint.Type, Double>>>();
		
		final class Coord {
			public int x, y;
			public Coord(int x, int y) { this.x = x; this.y = y; }
			public boolean equals(Object o) {
				if (!(o instanceof Coord)) return false;
				Coord oc = (Coord)o;
				return ((oc.x == x) && (oc.y == y));
			}
			public int hashCode() {
				return (x*31)^y;
			}
		}
		
		HashMap<Coord, Vector<FuzzyAllenIntervalConstraint>> multiple = new HashMap<Coord, Vector<FuzzyAllenIntervalConstraint>>();
		
		FuzzyAllenIntervalConstraint[][] tmp = new FuzzyAllenIntervalConstraint[getNumVars()][getNumVars()];
		
		int row = 0 , col = 0;
		for(int i = 0; i < c.length; i++){
			if(!isSubGraph){
				row = this.getID(c[i].getScope()[0]);
				col = this.getID(c[i].getScope()[1]);
			}
			else{
				row = (int)varIndex.get(c[i].getScope()[0].getID());
				col = (int)varIndex.get(c[i].getScope()[1].getID());
			}
			if (tmp[row][col] == null)
				tmp[row][col] = ((FuzzyAllenIntervalConstraint)c[i]);
			else {
				Coord coord = new Coord(row,col);
				Vector<FuzzyAllenIntervalConstraint> vec = multiple.get(coord);
				if (vec == null) {
					vec = new Vector<FuzzyAllenIntervalConstraint>();
					vec.add(tmp[row][col]);
					multiple.put(coord, vec);
				}
				vec.add((FuzzyAllenIntervalConstraint)c[i]);
			}
		}
		boolean isACrispCons = false;
		for(int i = 0; i < tmp.length; i++){
			Vector<HashMap<FuzzyAllenIntervalConstraint.Type, Double>> con = new Vector<HashMap<FuzzyAllenIntervalConstraint.Type, Double>>(); 
			for(int j = 0; j < tmp.length; j++){
				if(crispCons != null && tmp[i][j] != null){
					if(isACrispConstrint(tmp[i][j])) isACrispCons = true;
				}
				if(tmp[i][j] != null) {
					//add poss (i,j)
					/*
					System.out.println("----------------------------------");
					System.out.println("LOOKING AT " + tmpToConstraints.get(new Coords(i,j)) + ":\n" + (tmpToConstraints.get(new Coords(i,j))).getPossibilities());
					System.out.println("----------------------------------");
					*/
					Coord coord = new Coord(i,j);
					if (!multiple.containsKey(coord)) {
						if(!isACrispCons)
							con.add(tmp[i][j].getPossibilities());
						else
							con.add(tmp[i][j].makeCrispRel());
					}
					else {
						if(!isACrispCons){
							HashMap<FuzzyAllenIntervalConstraint.Type, Double> poss = multiple.get(coord).get(0).getPossibilities();
							for (int h = 1; h < multiple.get(coord).size(); h++) {
								updateRelation(poss, multiple.get(coord).get(h).getPossibilities());
							}
							con.add(poss);
						}
						else{
							HashMap<FuzzyAllenIntervalConstraint.Type, Double> poss = multiple.get(coord).get(0).makeCrispRel();
							for (int h = 1; h < multiple.get(coord).size(); h++) {
								updateRelation(poss, multiple.get(coord).get(h).makeCrispRel());
							}
							con.add(poss);
						}
					}
				}
				else if (tmp[j][i] != null) {
					//add inverse of (i,j)
					/*
					System.out.println("----------------------------------");
					System.out.println("LOOKING AT (I) " + tmpToConstraints.get(new Coords(j,i)) + ":\n" + (tmpToConstraints.get(new Coords(j,i))).getInversePossibilities());
					System.out.println("----------------------------------");
					*/
					Coord coord = new Coord(j,i);
					if(!isACrispCons){
						if (!multiple.containsKey(coord)) {
							con.add(tmp[j][i].getInversePossibilities());
						}
						else {
							HashMap<FuzzyAllenIntervalConstraint.Type, Double> poss = multiple.get(coord).get(0).getInversePossibilities();
							for (int h = 1; h < multiple.get(coord).size(); h++) {
								updateRelation(poss, multiple.get(coord).get(h).getInversePossibilities());
							}
							con.add(poss);
						}
					}
					else{
						if (!multiple.containsKey(coord)) {
							con.add(tmp[j][i].getCrispInverse());
						}
						else {
							HashMap<FuzzyAllenIntervalConstraint.Type, Double> poss = multiple.get(coord).get(0).getCrispInverse();
							for (int h = 1; h < multiple.get(coord).size(); h++) {
								updateRelation(poss, multiple.get(coord).get(h).getCrispInverse());
							}
							con.add(poss);
						}
					}
				}
				
				//if no relation exists, add [all possibilities <-- 1.0]
				else con.add(createAllFuzzyAllenRelation());
			}
			isACrispCons = false;
			frelations.add(con);
		}	
		
		return frelations;
	}
288012
@Override
	public BarrierFunction createPhase1BarrierFunction(){
		
		final int dimPh1 = dim +1;
		ConvexMultivariateRealFunction[] inequalitiesPh1 = new ConvexMultivariateRealFunction[this.fi.length];
		for(int i=0; i<inequalitiesPh1.length; i++){
			
			final ConvexMultivariateRealFunction originalFi = this.fi[i];
			
			ConvexMultivariateRealFunction fi = new ConvexMultivariateRealFunction() {
				
				@Override
				public double value(double[] Y) {
					DoubleMatrix1D y = DoubleFactory1D.dense.make(Y);
					DoubleMatrix1D X = y.viewPart(0, dim);
					return originalFi.value(X.toArray()) - y.get(dimPh1-1);
				}
				
				@Override
				public double[] gradient(double[] Y) {
					DoubleMatrix1D y = DoubleFactory1D.dense.make(Y);
					DoubleMatrix1D X = y.viewPart(0, dim);
					DoubleMatrix1D origGrad = F1.make(originalFi.gradient(X.toArray()));
					DoubleMatrix1D ret = F1.make(1, -1);
					ret = F1.append(origGrad, ret);
					return ret.toArray();
				}
				
				@Override
				public double[][] hessian(double[] Y) {
					DoubleMatrix1D y = DoubleFactory1D.dense.make(Y);
					DoubleMatrix1D X = y.viewPart(0, dim);
					DoubleMatrix2D origHess;
					double[][] origFiHessX = originalFi.hessian(X.toArray());
					if(origFiHessX == FunctionsUtils.ZEROES_2D_ARRAY_PLACEHOLDER){
						return FunctionsUtils.ZEROES_2D_ARRAY_PLACEHOLDER;
					}else{
						origHess = F2.make(origFiHessX);
						DoubleMatrix2D[][] parts = new DoubleMatrix2D[][]{{origHess, null},{null,F2.make(1, 1)}};
						return F2.compose(parts).toArray();
					}
				}
				
				@Override
				public int getDim() {
					return dimPh1;
				}
			};
			inequalitiesPh1[i] = fi;
		}
		
		BarrierFunction bfPh1 = new LogarithmicBarrier(inequalitiesPh1, dimPh1);
		return bfPh1;
	}
1187331
function(s) {
                //TODO: validate array length
		//TODO: return unwanted subset as new Px object

                var counts = this.valCounts(),
                multipliers = [];

                _.each(s, function(d, i) {
                    if (d[0] === '*') {
                        s[i] = _.range(0, counts[i] - 1);
                    }
                });

                for (var i = 0, l = counts.length; i < l - 1; i++) {
                    multipliers[i] = _.reduce(counts.slice(i+1), function(a, b) { return a * b; });
                }
                multipliers.push(1);

                for (var j = 0, k = s.length; j < k; j++) {
                    
                    // drop the values
                    this.metadata.VALUES[this.variables()[j]] = 
                        _.filter(this.metadata.VALUES[this.variables()[j]], function(e, m) {
                            return _.indexOf(s[j], m) !== -1;
                        });
                }

                var keepIdxs = [];
                var pattern = function pattern(c,m,w,p) {
                    if (c.length > 1) {
                        p = typeof p !== 'undefined' ? p : 1;
                        var count = c.pop(),
                            multiple = m.pop(),
                            want = w.pop();

                        var patt = _.flatten(_.map(_.range(0, count), function(d) { 
                            return _.include(want, d) ? p : _arrayOfZeroes(multiple);
                        }));

                        pattern(c, m, w, patt);
                    }
                    keepIdxs.push(_.flatten(p));
                };
                pattern(counts,multipliers,s);
                keepIdxs = keepIdxs[0];

                var indices = [];
                _.each(s[0], function(d) {
                    var start = d * multipliers[0];
                    var end = start + multipliers[0];
                    indices.push(_.filter(_.range(start, end), function(d, i) {return keepIdxs[i] === 1;}));
                });
                indices = _.flatten(indices);
                this.data = _.filter(this.data, function(d, i) {return _.indexOf(indices, i) !== -1;});
            }
35902
def method_missing(name, *args, &block)
      return super if block

      case args.size
        when 0

          # config.client?
          if name =~ /\A(\w+)\?\z/
            !!(respond_to?($1) ? send($1) : instance_variable_get("@#{ $1 }"))

          # config.client
          elsif name =~ /\A(\w+)\z/
            instance_variable_get("@#{ $1 }")

          else
            super
          end

        when 1
          # config.client=
          if name =~ /\A(\w+)=\z/
            instance_variable_set("@#{ $1 }", args.first)
          else
            super
          end
        else
          super
      end
    end
732331
@Override
	protected DoubleMatrix1D getUb() {
		if (this.limitedUb == null) {
			if (super.getUb() == null) {
				this.limitedUb = F1.make(getC().size(), maxUBValue);
			} else {
				this.limitedUb = F1.make(super.getUb().size());
				for (int i = 0; i < super.getUb().size(); i++) {
					double ubi = super.getUb().getQuick(i);
					if (maxUBValue < ubi) {
						log.warn("the " + i +"-th upper bound was limited form "+ubi+" to the value of maxUBValue: " + maxUBValue);
						limitedUb.setQuick(i, maxUBValue);
					} else {
						limitedUb.setQuick(i, ubi);
					}
				}
			}
		}
		return limitedUb;
	}
319821
@Override
  protected T doSwitch(int classifierID, EObject theEObject)
  {
    switch (classifierID)
    {
      case SimpleExpressionsPackage.IF_CONDITION:
      {
        IfCondition ifCondition = (IfCondition)theEObject;
        T result = caseIfCondition(ifCondition);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleExpressionsPackage.EXPRESSION:
      {
        Expression expression = (Expression)theEObject;
        T result = caseExpression(expression);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleExpressionsPackage.NUMBER_LITERAL:
      {
        NumberLiteral numberLiteral = (NumberLiteral)theEObject;
        T result = caseNumberLiteral(numberLiteral);
        if (result == null) result = caseExpression(numberLiteral);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleExpressionsPackage.BOOLEAN_LITERAL:
      {
        BooleanLiteral booleanLiteral = (BooleanLiteral)theEObject;
        T result = caseBooleanLiteral(booleanLiteral);
        if (result == null) result = caseExpression(booleanLiteral);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleExpressionsPackage.METHOD_CALL:
      {
        MethodCall methodCall = (MethodCall)theEObject;
        T result = caseMethodCall(methodCall);
        if (result == null) result = caseExpression(methodCall);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleExpressionsPackage.OR_EXPRESSION:
      {
        OrExpression orExpression = (OrExpression)theEObject;
        T result = caseOrExpression(orExpression);
        if (result == null) result = caseExpression(orExpression);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleExpressionsPackage.AND_EXPRESSION:
      {
        AndExpression andExpression = (AndExpression)theEObject;
        T result = caseAndExpression(andExpression);
        if (result == null) result = caseExpression(andExpression);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleExpressionsPackage.COMPARISON:
      {
        Comparison comparison = (Comparison)theEObject;
        T result = caseComparison(comparison);
        if (result == null) result = caseExpression(comparison);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleExpressionsPackage.NOT_EXPRESSION:
      {
        NotExpression notExpression = (NotExpression)theEObject;
        T result = caseNotExpression(notExpression);
        if (result == null) result = caseExpression(notExpression);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      default: return defaultCase(theEObject);
    }
  }
275311
private void pldltptBK() throws Exception {
		//matrix S will be changed by the factorization, ad we do not want to change the matrix passed in by the client
		DoubleMatrix2D S = (rescaler==null)? this.Q.copy() : this.Q;
		int n = S.rows();
		DoubleMatrix2D A = S.copy();
		this.P = DoubleFactory2D.sparse.identity(n);
		this.D = DoubleFactory2D.sparse.make(n, n);
		this.L = DoubleFactory2D.sparse.make(n, n);
		DoubleMatrix2D LT = ALG.transpose(L);//@TODO: remove and work only with L
		double mu = (1 + Math.sqrt(17)) / 8;
		int s = 0;
		for (int j = 0; j < n; j++) {
			//log.debug("j: " + j);
			DoubleMatrix2D LPart = null;
			DoubleMatrix2D LTPart = null;
			DoubleMatrix2D APart = null;
			DoubleMatrix2D DPart = null;
			
			//Determine largest off-diagonal element in column j
			double lambda = -1;
			int r = -1;
			for(int rr = j+1; rr<n; rr++){
				double d = Math.abs(A.getQuick(rr, j)); 
				if(d > lambda){
					lambda = d;
					r = rr;
				}
			}
			double ajj = A.getQuick(j, j);
			if (Math.abs(ajj) > mu*lambda) {
				// Choose a 1 x 1 pivot,
				D.setQuick(j, j, ajj);
				s = 1;
			} else {
				//Determine largest off-diagonal element in row/column r
				double sigma = -1;
				for(int rr = 0; rr<n; rr++){
					if(rr==r){
						continue;
					}
					double d = Math.abs(A.getQuick(rr, r)); 
					if(d > sigma){
						sigma = d;
					}
				}
				if(sigma * Math.abs(ajj) > mu*lambda*lambda){
					//Choose a 1 x 1 pivot,
					D.setQuick(j, j, A.getQuick(j, j));
					s = 1;
				}else if(Math.abs(A.getQuick(r, r)) > mu*sigma){
					//Symmetrically permute row/column r to position j
				  A = ColtUtils.symmPermutation(A, r, j);
					P.setQuick(r, r, 0);
					P.setQuick(j, j, 0);
					P.setQuick(r, j, 1);
					P.setQuick(j, r, 1);
					//Choose a 1 x 1 pivot,
					D.setQuick(j, j, A.getQuick(j, j));
					s = 1;
				}else{
					//Symmetrically permute rows/columns r and p to positions j and j + 1 respectively
					int t = j+1;
					//int v = j+1;
					A = ColtUtils.symmPermutation(A, r, t);
					P.setQuick(r, r, 0);
					P.setQuick(t, t, 0);
					P.setQuick(r, t, 1);
					P.setQuick(t, r, 1);
//					A = Utils.symmPermutation(A, p, v);
//					P.setQuick(p, p, 0);
//					P.setQuick(v, v, 0);
//					P.setQuick(p, v, 1);
//					P.setQuick(v, p, 1);
					//Choose a 2 x pivot,
					//D(j:j+1)(j:j+1) =  A(j:j+1)(j:j+1)
					D.setQuick(j, j, A.getQuick(j, j));
					D.setQuick(j, j+1, A.getQuick(j, j+1));
					D.setQuick(j+1, j, A.getQuick(j+1, j));
					D.setQuick(j+1, j+1, A.getQuick(j+1, j+1));
					s = 2;
				}
			}
			//log.debug("s: " + s);

			// L(j:n)(j:j+s-1) = A(j:n)(j:j+s-1).DInv(j:j+s-1)(j:j+s-1)
			APart = A.viewPart(j, j, n - j, 1 + s - 1);
//			if(s==2){
//				try{
//					ColtUtils.invert2x2Matrix(D.viewPart(j, j, 1 + s - 1, 1 + s - 1));
//				}catch(Exception e){
//					throw e;
//				}
//			}
			DPart = ALG.inverse(D.viewPart(j, j, 1 + s - 1, 1 + s - 1));
			LPart = L.viewPart(j, j, n - j, 1 + s - 1);
			DoubleMatrix2D AD = ALG.mult(APart, DPart);
			for (int rr = 0; rr < LPart.rows(); rr++) {
				for (int cc = 0; cc < LPart.columns(); cc++) {
					LPart.setQuick(rr, cc, AD.getQuick(rr, cc));
				}
			}

			// A(j+s-1:n)(j+s-1:n) = A(j+s-1:n)(j+s-1:n) -
			// L(j+s-1:n)(j:j+s-1).D(j:j+s-1)(j:j+s-1).LT(j:j+s-1)(j+s-1:n)
			LPart = L.viewPart(j + s - 1, j, n - (j + s - 1), 1 + s - 1);
			DPart = D.viewPart(j, j, 1 + s - 1, 1 + s - 1);
			LTPart = LT.viewPart(j, j + s - 1, s, n - (j + s - 1));
			APart = A.viewPart(j + s - 1, j + s - 1, n - (j + s - 1), n - (j + s - 1));
			DoubleMatrix2D LDLT = ALG.mult(LPart, ALG.mult(DPart, LTPart));
			for (int rr = 0; rr < APart.rows(); rr++) {
				for (int cc = 0; cc < APart.columns(); cc++) {
					APart.setQuick(rr, cc, APart.getQuick(rr, cc) - LDLT.getQuick(rr, cc));
				}
			}
			//logger.debug("L: " + ArrayUtils.toString(L.toArray()));
			//logger.debug("A: " + ArrayUtils.toString(A.toArray()));

			j = j + s - 1;
		}
	}
1117532
@Override
	public EObject create(EClass eClass) {
		switch (eClass.getClassifierID()) {
		case LogPackage.LOG_ACTION:
			return (EObject) createLogAction();
		case LogPackage.SERVER_LOG:
			return (EObject) createServerLog();
		case LogPackage.PROJECT_RELATED:
			return (EObject) createProjectRelated();
		case LogPackage.CHECKOUT_RELATED:
			return (EObject) createCheckoutRelated();
		case LogPackage.REVISION_RELATED:
			return (EObject) createRevisionRelated();
		case LogPackage.USER_RELATED:
			return (EObject) createUserRelated();
		case LogPackage.NEW_USER_ADDED:
			return (EObject) createNewUserAdded();
		case LogPackage.NEW_PROJECT_ADDED:
			return (EObject) createNewProjectAdded();
		case LogPackage.REVISION_BRANCHED:
			return (EObject) createRevisionBranched();
		case LogPackage.NEW_REVISION_ADDED:
			return (EObject) createNewRevisionAdded();
		case LogPackage.NEW_CHECKOUT_ADDED:
			return (EObject) createNewCheckoutAdded();
		case LogPackage.SETTINGS_SAVED:
			return (EObject) createSettingsSaved();
		case LogPackage.USER_ADDED_TO_PROJECT:
			return (EObject) createUserAddedToProject();
		case LogPackage.NEW_OBJECT_IDM_UPLOADED:
			return (EObject) createNewObjectIDMUploaded();
		case LogPackage.DOWNLOAD:
			return (EObject) createDownload();
		case LogPackage.USER_REMOVED_FROM_PROJECT:
			return (EObject) createUserRemovedFromProject();
		case LogPackage.PROJECT_DELETED:
			return (EObject) createProjectDeleted();
		case LogPackage.USER_DELETED:
			return (EObject) createUserDeleted();
		case LogPackage.PASSWORD_RESET:
			return (EObject) createPasswordReset();
		case LogPackage.DATABASE_CREATED:
			return (EObject) createDatabaseCreated();
		case LogPackage.SERVER_STARTED:
			return (EObject) createServerStarted();
		case LogPackage.PROJECT_UPDATED:
			return (EObject) createProjectUpdated();
		case LogPackage.USER_UNDELETED:
			return (EObject) createUserUndeleted();
		case LogPackage.PROJECT_UNDELETED:
			return (EObject) createProjectUndeleted();
		case LogPackage.REVISION_UPDATED:
			return (EObject) createRevisionUpdated();
		case LogPackage.GEO_TAG_UPDATED:
			return (EObject) createGeoTagUpdated();
		case LogPackage.PASSWORD_CHANGED:
			return (EObject) createPasswordChanged();
		case LogPackage.USER_CHANGED:
			return (EObject) createUserChanged();
		case LogPackage.EXTENDED_DATA_ADDED_TO_REVISION:
			return (EObject) createExtendedDataAddedToRevision();
		case LogPackage.EXTENDED_DATA_ADDED_TO_PROJECT:
			return (EObject) createExtendedDataAddedToProject();
		case LogPackage.REMOTE_SERVICE_CALLED:
			return (EObject) createRemoteServiceCalled();
		default:
			throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
		}
	}
164320
@Override
    public ZMatrixRMaj getT(ZMatrixRMaj T ) {
        T = UtilDecompositons_ZDRM.checkZeros(T,N,N);

        T.data[0] = QT.data[0];
        T.data[1] = QT.data[1];

        for( int i = 1; i < N; i++ ) {
            T.set(i,i, QT.getReal(i,i), QT.getImag(i,i));
            double real = QT.getReal(i-1,i);
            double imag = QT.getImag(i-1,i);
            T.set(i-1,i,real,imag);
            T.set(i,i-1,real,-imag);
        }

        return T;
    }
1356166
@Override
    public void ger(char order, double alpha, INDArray X, INDArray Y, INDArray A) {
        if (Nd4j.getExecutioner().getProfilingMode() == OpExecutioner.ProfilingMode.ALL)
            OpProfiler.getInstance().processBlasCall(false, A, X, Y);

        // FIXME: int cast

        if (X.data().dataType() == DataType.DOUBLE) {
            DefaultOpExecutioner.validateDataType(DataType.DOUBLE, A, X, Y);
            dger(order, (int) A.rows(), (int) A.columns(), alpha, X, X.stride(-1), Y, Y.stride(-1), A, (int) A.size(0));
        } else {
            DefaultOpExecutioner.validateDataType(DataType.FLOAT, A, X, Y);
            sger(order, (int) A.rows(), (int) A.columns(), (float) alpha, X, X.stride(-1), Y, Y.stride(-1), A, (int) A.size(0));
        }

        OpExecutionerUtil.checkForAny(A);
    }
1071749
private boolean isRawType(JvmTypeParameter current, RecursionGuard<JvmTypeParameter> guard) {
		if (guard.tryNext(current)) {
			List<JvmTypeConstraint> constraints = current.getConstraints();
			for(int i = 0, size = constraints.size(); i < size; i++) {
				JvmTypeConstraint constraint = constraints.get(i);
				if (constraint.eClass() == TypesPackage.Literals.JVM_UPPER_BOUND && constraint.getTypeReference() != null) {
					JvmTypeReference superType = constraint.getTypeReference();
					JvmType rawSuperType = superType.getType();
					if (rawSuperType != null) {
						if (rawSuperType.eClass() == TypesPackage.Literals.JVM_TYPE_PARAMETER) {
							if (isRawType((JvmTypeParameter) rawSuperType, guard)) {
								return true;
							}
						}
						if (rawSuperType.eClass() == TypesPackage.Literals.JVM_GENERIC_TYPE) {
							if (!((JvmGenericType) rawSuperType).getTypeParameters().isEmpty()) {
								if (superType.eClass() == TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE) {
									JvmParameterizedTypeReference casted = (JvmParameterizedTypeReference) superType;
									if (casted.getArguments().isEmpty()) {
										return true;
									}
								}
							}
						}
					}
				}
			}
		}
		return false;
	}
1074407
public void EBEsElementsTopology(DoubleSolution solution) throws JMetalException{
    // asignaciÃƒÂ³n de las variables para cada grupo
    // y determinaciÃƒÂ³n de las caracterÃƒÂ­sticas mecÃƒÂ¡nicas

    double[] x = new double[solution.getNumberOfVariables()];
    for (int i = 0; i < solution.getNumberOfVariables(); i++) {
      x[i] = solution.getVariableValue(i) ;
    }

    double x1, x2, x3, x4;

    int var=0;
    for (int gr=0; gr<numberOfGroupElements_;gr++){

      var+=Groups_[gr][VARIABLES];

      if (Groups_[gr][SHAPE]==CIRCLE){
        x1=x[var-1]; // diameter
        EBEsTransversalSectionCircular(gr, x1);
      }
      else if (Groups_[gr][SHAPE]==HOLE_CIRCLE){
        x1=x[var-2]; // diameter
        x2=x[var-1]; // tickness plate
        EBEsTransversalSectionHoleCircular(gr, x1, x2);
      }
      else if (Groups_[gr][SHAPE]==RECTANGLE){
        x1=x[var-2]; // higth (y axis)
        x2=x[var-1]; // witdth (z axis)
        EBEsTransversalSectionRectangle(gr, x1, x2);
      }
      else if (Groups_[gr][SHAPE]==HOLE_RECTANGLE){
        x1=x[var-4]; // height (y axis)
        x2=x[var-3]; // width (z axis)
        x3=x[var-2]; // horizontal plate tickness (up and down)
        x4=x[var-1]; // vertical plate tickness (left and right)
        EBEsTransversalSectionHoleRectangle(gr, x1, x2, x3, x4);
      }
      else if (Groups_[gr][SHAPE]==I_SINGLE){

        //EbesMutation(gr, 0, x);

        x1=x[var-4]; // height (y axis)
        x2=x[var-3]; // width (Z axis)
        x3=x[var-2]; // plate tickness heigth and down
        x4=x[var-1]; // vertical plate tickness (centre)
        EBEsTransversalSection_I_Single(gr, x1, x2, x3, x4);
      }
      else if (Groups_[gr][SHAPE]==I_DOUBLE){
        x1=x[var-4]; // height (y axis)
        x2=x[var-3]; // width (Z axis)
        x3=x[var-2]; // tickness heigth plate
        x4=x[var-1]; // tickness width plate
        EBEsTransversalSection_I_Double(gr, x1, x2, x3, x4);
      }
      else if (Groups_[gr][SHAPE]==H_SINGLE){
        x1=x[var-4]; // height (y axis)
        x2=x[var-3]; // width (Z axis)
        x3=x[var-2]; // tickness heigth plate
        x4=x[var-1]; // tickness width plate
        EBEsTransversalSection_H_Single(gr, x1, x2, x3, x4);
      }
      else if (Groups_[gr][SHAPE]==H_DOUBLE){
        x1=x[var-4]; // height (y axis)
        x2=x[var-3]; // width (Z axis)
        x3=x[var-2]; // tickness heigth plate
        x4=x[var-1]; // tickness width plate
        EBEsTransversalSection_H_Double(gr, x1, x2, x3, x4);
      }
      else if (Groups_[gr][SHAPE]==L_SINGLE){
        x1=x[var-4]; // height (y axis)
        x2=x[var-3]; // width (Z axis)
        x3=x[var-2]; // tickness heigth plate
        x4=x[var-1]; // tickness width plate
        EBEsTransversalSection_L_Single(gr, x1, x2, x3, x4);
      }
      else if (Groups_[gr][SHAPE]==L_DOUBLE){
        x1=x[var-4]; // height (y axis)
        x2=x[var-3]; // width (Z axis)
        x3=x[var-2]; // tickness heigth plate
        x4=x[var-1]; // tickness width plate
        EBEsTransversalSection_L_Double(gr, x1, x2, x3, x4);
      }
      else if (Groups_[gr][SHAPE]==T_SINGLE){
        x1=x[var-4]; // height (y axis)
        x2=x[var-3]; // width (Z axis)
        x3=x[var-2]; // tickness heigth plate
        x4=x[var-1]; // tickness width plate
        EBEsTransversalSection_T_Single(gr, x1, x2, x3, x4);
      }
      else if (Groups_[gr][SHAPE]==T_DOUBLE){
        x1=x[var-4]; // height (y axis)
        x2=x[var-3]; // width (Z axis)
        x3=x[var-2]; // tickness heigth plate
        x4=x[var-1]; // tickness width plate
        EBEsTransversalSection_T_Double(gr, x1, x2, x3, x4);
      }
      else{
        System.out.println("Error in VARIABLES: transversal section not considerated for: " + gr + " group") ;
      }
    }// next gr

  }
1361502
private void verifyInput() {
        if (inData == null || inStations == null) {
            throw new NullPointerException(msg.message("kriging.stationproblem"));
        }
        if (pMode < 0 || pMode > 1) {
            throw new IllegalArgumentException(msg.message("kriging.defaultMode"));
        }

        if (defaultVariogramMode != 0 && defaultVariogramMode != 1) {
            throw new IllegalArgumentException(msg.message("kriging.variogramMode"));
        }
        if (defaultVariogramMode == 0) {
            if (pVariance == 0 || pIntegralscale[0] == 0 || pIntegralscale[1] == 0 || pIntegralscale[2] == 0) {

                pm.errorMessage(msg.message("kriging.noParam"));
                pm.errorMessage("varianza " + pVariance);
                pm.errorMessage("Integral scale x " + pIntegralscale[0]);
                pm.errorMessage("Integral scale y " + pIntegralscale[1]);
                pm.errorMessage("Integral scale z " + pIntegralscale[2]);
            }
        }
        if (defaultVariogramMode == 1) {
            if (pNug == 0 || pS == 0 || pA == 0) {
                pm.errorMessage(msg.message("kriging.noParam"));
                pm.errorMessage("Nugget " + pNug);
                pm.errorMessage("Sill " + pS);
                pm.errorMessage("Range " + pA);
            }
        }

        if ((pMode == 0) && inInterpolate == null) {
            throw new ModelsIllegalargumentException(msg.message("kriging.noPoint"), this, pm);
        }
        if (pMode == 1 && inInterpolationGrid == null) {
            throw new ModelsIllegalargumentException("The gridded interpolation needs a gridgeometry in input.", this, pm);
        }

    }
451925
@Override
  protected T doSwitch(int classifierID, EObject theEObject)
  {
    switch (classifierID)
    {
      case SimpleAntlrPackage.ANTLR_GRAMMAR:
      {
        AntlrGrammar antlrGrammar = (AntlrGrammar)theEObject;
        T result = caseAntlrGrammar(antlrGrammar);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.OPTIONS:
      {
        Options options = (Options)theEObject;
        T result = caseOptions(options);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.OPTION_VALUE:
      {
        OptionValue optionValue = (OptionValue)theEObject;
        T result = caseOptionValue(optionValue);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.RULE:
      {
        Rule rule = (Rule)theEObject;
        T result = caseRule(rule);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.PARAMETER:
      {
        Parameter parameter = (Parameter)theEObject;
        T result = caseParameter(parameter);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.RULE_ELEMENT:
      {
        RuleElement ruleElement = (RuleElement)theEObject;
        T result = caseRuleElement(ruleElement);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.EXPRESSION:
      {
        Expression expression = (Expression)theEObject;
        T result = caseExpression(expression);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.REFERENCE_OR_LITERAL:
      {
        ReferenceOrLiteral referenceOrLiteral = (ReferenceOrLiteral)theEObject;
        T result = caseReferenceOrLiteral(referenceOrLiteral);
        if (result == null) result = caseExpression(referenceOrLiteral);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.PREDICATED:
      {
        Predicated predicated = (Predicated)theEObject;
        T result = casePredicated(predicated);
        if (result == null) result = caseRuleElement(predicated);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.RULE_OPTIONS:
      {
        RuleOptions ruleOptions = (RuleOptions)theEObject;
        T result = caseRuleOptions(ruleOptions);
        if (result == null) result = caseRuleElement(ruleOptions);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.RULE_CALL:
      {
        RuleCall ruleCall = (RuleCall)theEObject;
        T result = caseRuleCall(ruleCall);
        if (result == null) result = caseRuleElement(ruleCall);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.KEYWORD:
      {
        Keyword keyword = (Keyword)theEObject;
        T result = caseKeyword(keyword);
        if (result == null) result = caseRuleElement(keyword);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.WILDCARD:
      {
        Wildcard wildcard = (Wildcard)theEObject;
        T result = caseWildcard(wildcard);
        if (result == null) result = caseRuleElement(wildcard);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.ALTERNATIVES:
      {
        Alternatives alternatives = (Alternatives)theEObject;
        T result = caseAlternatives(alternatives);
        if (result == null) result = caseRuleElement(alternatives);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.GROUP:
      {
        Group group = (Group)theEObject;
        T result = caseGroup(group);
        if (result == null) result = caseRuleElement(group);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.ELEMENT_WITH_CARDINALITY:
      {
        ElementWithCardinality elementWithCardinality = (ElementWithCardinality)theEObject;
        T result = caseElementWithCardinality(elementWithCardinality);
        if (result == null) result = caseRuleElement(elementWithCardinality);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.NEGATED_ELEMENT:
      {
        NegatedElement negatedElement = (NegatedElement)theEObject;
        T result = caseNegatedElement(negatedElement);
        if (result == null) result = caseRuleElement(negatedElement);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.UNTIL_ELEMENT:
      {
        UntilElement untilElement = (UntilElement)theEObject;
        T result = caseUntilElement(untilElement);
        if (result == null) result = caseRuleElement(untilElement);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.OR_EXPRESSION:
      {
        OrExpression orExpression = (OrExpression)theEObject;
        T result = caseOrExpression(orExpression);
        if (result == null) result = caseExpression(orExpression);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.AND_EXPRESSION:
      {
        AndExpression andExpression = (AndExpression)theEObject;
        T result = caseAndExpression(andExpression);
        if (result == null) result = caseExpression(andExpression);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.NOT_EXPRESSION:
      {
        NotExpression notExpression = (NotExpression)theEObject;
        T result = caseNotExpression(notExpression);
        if (result == null) result = caseExpression(notExpression);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      case SimpleAntlrPackage.SKIP:
      {
        Skip skip = (Skip)theEObject;
        T result = caseSkip(skip);
        if (result == null) result = caseRuleOptions(skip);
        if (result == null) result = caseRuleElement(skip);
        if (result == null) result = defaultCase(theEObject);
        return result;
      }
      default: return defaultCase(theEObject);
    }
  }
622445
@Override
	protected T doSwitch(int classifierID, EObject theEObject) {
		switch (classifierID) {
			case BasePackage.AFP: {
				AFP afp = (AFP)theEObject;
				T result = caseAFP(afp);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case BasePackage.SF: {
				SF sf = (SF)theEObject;
				T result = caseSF(sf);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case BasePackage.UNKNSF: {
				UNKNSF unknsf = (UNKNSF)theEObject;
				T result = caseUNKNSF(unknsf);
				if (result == null) result = caseSF(unknsf);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case BasePackage.SF_GROUPER: {
				SFGrouper sfGrouper = (SFGrouper)theEObject;
				T result = caseSFGrouper(sfGrouper);
				if (result == null) result = caseSF(sfGrouper);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			case BasePackage.TRIPLET: {
				Triplet triplet = (Triplet)theEObject;
				T result = caseTriplet(triplet);
				if (result == null) result = defaultCase(theEObject);
				return result;
			}
			default: return defaultCase(theEObject);
		}
	}