List of usage examples for org.apache.commons.math3.stat.descriptive.moment Mean Mean
public Mean()
From source file:in.ac.iitb.cse.cartsbusboarding.acc.FeatureCalculator.java
/** * Calculates mean of whatever data is given to this function * * @return/*from w w w . j a v a2 s. c o m*/ */ private double calculateMean(double input[]) { return ((new Mean()).evaluate(input)); }
From source file:com.github.lindenb.jvarkit.tools.redon.CopyNumber01.java
private void normalizeCoverage() { final Median medianOp = new Median(); final Mean meanOp = new Mean(); if (medianOp.evaluate(new double[] { 20, 1000, 19 }) != 20) { throw new RuntimeException("boum"); }//from w w w. jav a2 s . c om int autosome_count = 0; Collections.sort(this.interval2row, CopyNumber01.sortOnXY); for (int j = 0; j < this.interval2row.size(); ++j) { GCAndDepth r = this.interval2row.get(j); if (isSexualChrom(r.getChrom())) continue; autosome_count++; } double x[] = new double[autosome_count]; double y[] = new double[autosome_count]; int i = 0; for (int j = 0; j < this.interval2row.size(); ++j) { GCAndDepth r = this.interval2row.get(j); if (isSexualChrom(r.getChrom())) continue; x[i] = r.getX(); y[i] = r.getY(); ++i; } final double min_x = x[0]; final double max_x = x[x.length - 1]; /* merge adjacent x having same values */ i = 0; int k = 0; while (i < x.length) { int j = i + 1; while (j < x.length && Double.compare(x[i], x[j]) == 0) { ++j; } x[k] = x[i]; y[k] = meanOp.evaluate(y, i, j - i); ++k; i = j; } /* reduce size of x et y */ if (k != x.length) { info("Compacting X from " + x.length + " to " + k); x = Arrays.copyOf(x, k); y = Arrays.copyOf(y, k); } //min depth cal double min_depth = Double.MAX_VALUE; UnivariateInterpolator interpolator = createInterpolator(); UnivariateFunction spline = interpolator.interpolate(x, y); int points_removed = 0; i = 0; while (i < this.interval2row.size()) { GCAndDepth r = this.interval2row.get(i); if (r.getX() < min_x || r.getX() > max_x) { this.interval2row.remove(i); ++points_removed; } else { double norm = spline.value(r.getX()); if (Double.isNaN(norm) || Double.isInfinite(norm)) { info("NAN " + r); this.interval2row.remove(i); ++points_removed; continue; } r.depth -= norm; min_depth = Math.min(min_depth, r.depth); ++i; } } info("Removed " + points_removed + " because GC% is too small (Sexual chrom)"); spline = null; //fit to min, fill new y for median calculation info("min:" + min_depth); y = new double[this.interval2row.size()]; for (i = 0; i < this.interval2row.size(); ++i) { GCAndDepth gc = this.interval2row.get(i); gc.depth -= min_depth; y[i] = gc.depth; } //normalize on median double median_depth = medianOp.evaluate(y, 0, y.length); info("median:" + median_depth); for (i = 0; i < this.interval2row.size(); ++i) { GCAndDepth gc = this.interval2row.get(i); gc.depth /= median_depth; } //restore genomic order Collections.sort(this.interval2row, CopyNumber01.sortOnPosition); /** smoothing values with neighbours */ final int SMOOTH_WINDOW = 5; y = new double[this.interval2row.size()]; for (i = 0; i < this.interval2row.size(); ++i) { y[i] = this.interval2row.get(i).getY(); } for (i = 0; i < this.interval2row.size(); ++i) { GCAndDepth gc = this.interval2row.get(i); int left = i; int right = i; while (left > 0 && i - left < SMOOTH_WINDOW && this.interval2row.get(left - 1).tid == gc.tid) { left--; } while (right + 1 < this.interval2row.size() && right - i < SMOOTH_WINDOW && this.interval2row.get(right + 1).tid == gc.tid) { right++; } gc.depth = medianOp.evaluate(y, left, (right - left) + 1); } }
From source file:com.itemanalysis.psychometrics.irt.estimation.StartingValues.java
/** * Computes normal approximation estimates (PROX) of item difficulty and person ability * in a way that allows for missing data (Linacre, 1994). It is an iterative procedure. * * Linacre, J. M., (1994). PROX with missing data, or known item or person measures. * Rasch Measurement Transactions, 8:3, 378, http://www.rasch.org/rmt/rmt83g.htm. * * @param converge convergence criterion as the maximum change in person logits. * @param maxIter maximum number of iterations. About 10 iterations works well. *//*from w w w . j a v a2 s .co m*/ private void prox(double converge, int maxIter) { double delta = 1.0 + converge; int iter = 0; double pProx = 0; double pScore = 0; double maxTestScore = 0; double maxChange = 0; double logit = 0; Mean personGrandMean = new Mean(); StandardDeviation personGrandSd = new StandardDeviation(); double iProx = 0.0; double iMean = 0; theta = new double[nResponseVectors]; Mean[] mPerson = new Mean[nItems];//Item difficulty mean for those examinees completing item j StandardDeviation[] sdPerson = new StandardDeviation[nItems];//Item difficulty standard deviation for those examinees completing item j double[] Si = null; double[] Ni = null; Mean[] mItem = new Mean[nResponseVectors]; StandardDeviation[] sdItem = new StandardDeviation[nResponseVectors]; while (delta > converge && iter < maxIter) { Si = new double[nItems]; Ni = new double[nItems]; //Compute descriptive statistics for persons and items double resp = 0; double freq = 0; for (int l = 0; l < nResponseVectors; l++) { freq = responseVector[l].getFrequency(); for (int j = 0; j < nItems; j++) { //initialize arrays if (l == 0) { mPerson[j] = new Mean(); sdPerson[j] = new StandardDeviation(); } if (j == 0) { mItem[l] = new Mean(); sdItem[l] = new StandardDeviation(); } if (irm[j].getType() == IrmType.L3 || irm[j].getType() == IrmType.L4) { resp = responseVector[l].getResponseAt(j); //increment item and person summary statistics if (resp != -1) { //incorporate weights - crude workaround for (int w = 0; w < freq; w++) { mItem[l].increment(irm[j].getDifficulty()); sdItem[l].increment(irm[j].getDifficulty()); mPerson[j].increment(theta[l]); sdPerson[j].increment(theta[l]); Si[j] += resp; Ni[j]++; } } } } //end item loop } //end summary loop //Compute item PROX for binary items only iMean = 0; double pSd = 1e-8; double ni = 0; for (int j = 0; j < nItems; j++) { if (irm[j].getType() == IrmType.L3 || irm[j].getType() == IrmType.L4) { pSd = sdPerson[j].getResult(); //adjust extreme item scores if (Si[j] == 0) Si[j] += 0.3; if (Si[j] == Ni[j]) Si[j] -= 0.3; logit = Math.log(Si[j] / (Ni[j] - Si[j])); iProx = mPerson[j].getResult() - Math.sqrt(1.0 + pSd / 2.9) * logit; irm[j].setDifficulty(iProx); iMean += iProx; ni++; } } iMean /= ni; //center difficulties about the mean item difficulty for (int j = 0; j < nItems; j++) { if (irm[j].getType() == IrmType.L3 || irm[j].getType() == IrmType.L4) { iProx = irm[j].getDifficulty(); irm[j].setDifficulty(iProx - iMean); } } //Compute person PROX maxChange = 0; personGrandMean.clear(); personGrandSd.clear(); Pair<Double, Double> personScores = null; for (int l = 0; l < nResponseVectors; l++) { personScores = computePersonScores(responseVector[l]); pScore = personScores.getFirst(); maxTestScore = personScores.getSecond(); //adjust extreme person scores if (pScore == 0) pScore += 0.3; if (pScore == maxTestScore) pScore -= 0.3; logit = Math.log(pScore / (maxTestScore - pScore)); pProx = mItem[l].getResult() + Math.sqrt(1.0 + sdItem[l].getResult() / 2.9) * logit; maxChange = Math.max(maxChange, Math.abs(theta[l] - pProx)); theta[l] = pProx; personGrandMean.increment(pProx); personGrandSd.increment(pProx); } delta = maxChange; iter++; fireEMStatusEvent(iter, delta, Double.NaN); } //end while //Linearly transform theta estimate to have a mean of 0 and a standard deviation of 1. //Apply the same transformation to item difficulty values. double A = 1.0 / personGrandSd.getResult(); double B = -A * personGrandMean.getResult(); for (int l = 0; l < nResponseVectors; l++) { theta[l] = theta[l] * A + B; } double a = 1; double b = 0; for (int j = 0; j < nItems; j++) { if (irm[j].getType() == IrmType.L3 || irm[j].getType() == IrmType.L3) { b = irm[j].getDifficulty(); irm[j].setDifficulty(b * A + B); //Adjust discrimination parameter for scaling constant. //PROX assumes a logit scale. This conversion is to convert to the normal metric. a = irm[j].getDiscrimination(); irm[j].setDiscrimination(a / irm[j].getScalingConstant()); } } //For debugging // System.out.println("ITER: " + iter); // for(int j=0;j<nItems;j++){ // System.out.println("PROX: " + irm[j].toString()); // } }
From source file:com.vmware.photon.controller.cloudstore.xenon.entity.SchedulingConstantGeneratorTest.java
/** * Compute the coefficient of variation of the gaps between adjacent * scheduling constants.//from ww w . j a va2s . c om * * @param schedulingConstants Sorted list of scheduling constants. */ private double schedulingConstantGapCV(List<Long> schedulingConstants) { // Compute the difference between each scheduling constant and the next. double[] gaps = new double[schedulingConstants.size()]; for (int i = 0; i < schedulingConstants.size(); i++) { long gap; // Special case at end of list: wrap around if (i == schedulingConstants.size() - 1) { gap = schedulingConstants.get(0) - schedulingConstants.get(i) + 10000; } else { gap = schedulingConstants.get(i + 1) - schedulingConstants.get(i); } gaps[i] = (double) gap; } // Compute coefficient of variation double gapMean = new Mean().evaluate(gaps); double gapSD = new StandardDeviation().evaluate(gaps); return gapSD / gapMean; }
From source file:com.itemanalysis.psychometrics.irt.estimation.JointMaximumLikelihoodEstimation.java
/** * This method manages the item updates during the JMLE iterations. * * @param delta current value of the maximum observed change in logits * @param centerItems establish identification by centering item about the item difficulty mean (the approach * typically used in Rasch measurement). If false establish identification by centering * persons around the mean ability. Centering only done for nonextreme persons and items. * @return maximum change in logits observed during the item updates *///from ww w. j a v a2 s. c o m private double updateAllItems(double delta, boolean centerItems) { double maxDelta = 0.0; double difficulty = 0.0; double tempDifficulty = 0.0; Mean mean = new Mean(); boolean hasFixed = false; //update each non extreme item for (int j = 0; j < nItems; j++) { if (droppedStatus[j] == 0) { tempDifficulty = updateDifficulty(irm[j], itemSummary[j], delta); if (extremeItem[j] == 0) mean.increment(tempDifficulty); } if (irm[j].isFixed()) hasFixed = true; } //Center non extreme items about the mean item difficulty. //Accept all proposal values. for (int j = 0; j < nItems; j++) { if (hasFixed) { //with fixed values, there is no need to constrain item difficulty to be zero. maxDelta = Math.max(maxDelta, Math.abs(irm[j].getProposalDifficulty() - irm[j].getDifficulty())); } else { //without fixed item parameter, constrain item difficulty to be zero. if (droppedStatus[j] == 0 && extremeItem[j] == 0) { difficulty = irm[j].getDifficulty(); tempDifficulty = irm[j].getProposalDifficulty(); if (centerItems) tempDifficulty -= mean.getResult();//center irm[j].setProposalDifficulty(tempDifficulty); maxDelta = Math.max(maxDelta, Math.abs(tempDifficulty - difficulty)); } } } return maxDelta; }
From source file:com.itemanalysis.psychometrics.irt.estimation.JointMaximumLikelihoodEstimation.java
/** * Thresholds for a single rating scale group are updated in this method. Updates only involve nonextreme * examinees that respond to the item.//from ww w . jav a 2s . c o m * * @param raschRatingScaleGroup group for which thresholds are updated. * @return maximum change in logits for this update. */ private double updateThresholds(RaschRatingScaleGroup raschRatingScaleGroup) { double thresh = 0.0; int[] pos = raschRatingScaleGroup.getPositions(); int nCat = raschRatingScaleGroup.getNumberOfCategories(); double[] catKSum = new double[nCat]; double[] thresholds = null; double[] proposalThresholds = new double[nCat - 1]; Mean tMean = new Mean(); double maxDelta = 0.0; thresholds = raschRatingScaleGroup.getThresholds(); for (int i = 0; i < nPeople; i++) { if (extremePerson[i] == 0) { thresholds = raschRatingScaleGroup.getThresholds(); for (int k = 0; k < nCat; k++) { catKSum[k] += raschRatingScaleGroup.probabilitySumAt(theta[i], k); } } } int prevCat = 0; int nextCat = 0; for (int k = 0; k < nCat - 1; k++) { nextCat++; thresh = thresholds[k]; proposalThresholds[k] = thresh - Math.log(raschRatingScaleGroup.TpjAt(nextCat) / raschRatingScaleGroup.TpjAt(prevCat)) + Math.log(catKSum[nextCat] / catKSum[prevCat]); //do not change threshold by more than one logit - from WINSTEPS documentation proposalThresholds[k] = Math.max(Math.min(thresh + 1.0, proposalThresholds[k]), thresh - 1.0); tMean.increment(proposalThresholds[k]); prevCat = nextCat; } //recenter thresholds around the mean threshold double m = tMean.getResult(); for (int k = 0; k < nCat - 1; k++) { proposalThresholds[k] = proposalThresholds[k] - m; maxDelta = Math.max(Math.abs(proposalThresholds[k] - thresholds[k]), maxDelta); } raschRatingScaleGroup.setProposalThresholds(proposalThresholds); return maxDelta; }
From source file:com.itemanalysis.psychometrics.irt.estimation.JointMaximumLikelihoodEstimation.java
/** * Update of all persons is handled here. * * @param maxIter maximum number of iteration in the person update. * @param converge convergence criterion for the person update. The criterion is the maximum change in logits. * @param adjustment extreme score adjustment. * @param centerItems establish identification by centering item about the item difficulty mean (the approach * typically used in Rasch measurement). If false establish identification by centering * persons around the mean ability. Centering only done for nonextreme persons and items. * @return maximum observed value change in logits from updating all examinees. *///w ww . ja v a2 s . c om private double updateAllPersons(int maxIter, double converge, double adjustment, boolean centerItems) { double maxDelta = 0.0; double tempTheta = 0.0; Mean personMean = new Mean(); for (int i = 0; i < nPeople; i++) { tempTheta = theta[i]; theta[i] = updatePerson(i, maxIter, converge, adjustment); if (extremePerson[i] == 0) { personMean.increment(theta[i]); maxDelta = Math.max(Math.abs(theta[i] - tempTheta), maxDelta); } } if (!centerItems) { double m = personMean.getResult(); for (int i = 0; i < nPeople; i++) { if (extremePerson[i] == 0) theta[i] -= m; } } return maxDelta; }
From source file:com.udojava.evalex.Expression.java
/** * Creates a new expression instance from an expression string with a given * default match context./*from ww w. j a v a 2 s . c o m*/ * * @param expression The expression. E.g. <code>"2.4*sin(3)/(2-4)"</code> or * <code>"sin(y)>0 & max(z, 3)>3"</code> */ public Expression(String expression, LinkedList<String> hist, Variables vars) { this.history = hist; this.expression = expression; mainVars = vars; addOperator(new Operator("+", 20, true, "Addition") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { if (v1.type == ValueType.ARRAY) { MyComplex vo = new MyComplex(v1.list); vo.list.add(v2); return vo; } return v1.add(v2); } }); addOperator(new Operator("-", 20, true, "Subtraction") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { if (v1.type == ValueType.ARRAY) { MyComplex vo = new MyComplex(v1.list); vo.list.removeIf(o -> o.equals(v2)); return vo; } return v1.subtract(v2); } }); addOperator(new Operator("*", 30, true, "Real number multiplication") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { return v1.multiply(v2); } }); addOperator(new Operator("/", 30, true, "Real number division") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { return v1.divide(v2); } }); addOperator(new Operator("%", 30, true, "Remainder of integer division") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { double r = v1.real % v2.real; return new MyComplex(r); } }); addOperator( new Operator("^", 40, false, "Exponentation. See: https://en.wikipedia.org/wiki/Exponentiation") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { return v1.pow(v2); } }); addOperator(new Operator("&&", 4, false, "Logical AND. Evaluates to 1 if both operands are not 0") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { boolean b1 = (v1.real == 0.0 && v2.real == 0.0); return new MyComplex(b1 ? 1 : 0); } }); addOperator(new Operator("||", 2, false, "Logical OR. Evaluates to 0 if both operands are 0") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { boolean b1 = (v1.real == 0.0 && v2.real == 0.0); return new MyComplex(b1 ? 0 : 1); } }); addOperator(new Operator(">", 10, false, "Greater than. See: See: https://en.wikipedia.org/wiki/Inequality_(mathematics)") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { if (v1.type == ValueType.REAL && v2.type == ValueType.REAL) { return new MyComplex(v1.real > v2.real ? 1 : 0); } else { return new MyComplex(v1.abs() > v2.abs() ? 1 : 0); } } }); addOperator(new Operator(">=", 10, false, "Greater or equal") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { if (v1.type == ValueType.REAL && v2.type == ValueType.REAL) { return new MyComplex(v1.real >= v2.real ? 1 : 0); } else { return new MyComplex(v1.abs() >= v2.abs() ? 1 : 0); } } }); addOperator(new Operator("<", 10, false, "Less than. See: https://en.wikipedia.org/wiki/Inequality_(mathematics)") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { if (v1.type == ValueType.REAL && v2.type == ValueType.REAL) { return new MyComplex(v1.real < v2.real ? 1 : 0); } else { return new MyComplex(v1.abs() < v2.abs() ? 1 : 0); } } }); addOperator(new Operator("<=", 10, false, "less or equal") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { if (v1.type == ValueType.REAL && v2.type == ValueType.REAL) { return new MyComplex(v1.real <= v2.real ? 1 : 0); } else { return new MyComplex(v1.abs() <= v2.abs() ? 1 : 0); } } }); addOperator(new Operator("->", 7, false, "Set variable v to new value ") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { if (v1 instanceof PitDecimal) { PitDecimal target = (PitDecimal) v1; String s = target.getVarToken(); setVariable(s, v2); return v2; } throw new ExpressionException("LHS not variable"); } }); addOperator(new Operator("=", 7, false, "Equality") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { if (v1.type == ValueType.REAL && v2.type == ValueType.REAL) { return new MyComplex(v1.real == v2.real ? 1 : 0); } else { return new MyComplex(v1.abs() == v2.abs() ? 1 : 0); } } }); addOperator(new Operator("!=", 7, false, "Inequality. See: https://en.wikipedia.org/wiki/Inequality_(mathematics)") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { if (v1.type == ValueType.REAL && v2.type == ValueType.REAL) { return new MyComplex(v1.real != v2.real ? 1 : 0); } else { return new MyComplex(v1.abs() != v2.abs() ? 1 : 0); } } }); addOperator( new Operator("or", 7, false, "Bitwise OR. See: https://en.wikipedia.org/wiki/Logical_disjunction") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { return new MyComplex((long) v1.real | (long) v2.real); } }); addOperator(new Operator("and", 7, false, "Bitwise AND. See: https://en.wikipedia.org/wiki/Logical_conjunction") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { return new MyComplex((long) v1.real & (long) v2.real); } }); addOperator(new Operator("xor", 7, false, "Bitwise XOR, See: https://en.wikipedia.org/wiki/Exclusive_or") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { return new MyComplex((long) v1.real ^ (long) v2.real); } }); addOperator(new Operator("!", 50, true, "Factorial. See https://en.wikipedia.org/wiki/Factorial") { public BigInteger factorial(long n) { BigInteger factorial = BigInteger.ONE; for (long i = 1; i <= n; i++) { factorial = factorial.multiply(BigInteger.valueOf(i)); } return factorial; } @Override public MyComplex eval(MyComplex v1, MyComplex v2) { BigInteger fact = factorial((long) v1.real); return new MyComplex(fact, BigInteger.ZERO); } }); addOperator(new Operator("~", 8, false, "Bitwise negation") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { BigInteger bi = v2.toBigIntegerReal(); int c = bi.bitLength(); if (c == 0) { return new MyComplex(1); } for (int s = 0; s < c; s++) { bi = bi.flipBit(s); } return new MyComplex(bi); } }); addOperator(new Operator("shl", 8, false, "Left Bit shift") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { return new MyComplex((long) v1.real << (long) v2.real); } }); addOperator(new Operator("shr", 8, false, "Right bit shift") { @Override public MyComplex eval(MyComplex v1, MyComplex v2) { return new MyComplex((long) v1.real >>> (long) v2.real); } }); addFunction(new Function("NOT", 1, "evaluates to 0 if argument != 0") { @Override public MyComplex eval(List<MyComplex> parameters) { boolean zero = parameters.get(0).abs() == 0; return new MyComplex(zero ? 1 : 0); } }); addFunction(new Function("RND", 2, "Give random number in the range between first and second argument") { @Override public MyComplex eval(List<MyComplex> parameters) { double low = parameters.get(0).real; double high = parameters.get(1).real; return new MyComplex(low + Math.random() * (high - low)); } }); MersenneTwister mers = new MersenneTwister(System.nanoTime()); addFunction(new Function("MRS", 0, "Mersenne twister random generator") { @Override public MyComplex eval(List<MyComplex> parameters) { return new MyComplex(mers.nextDouble()); } }); addFunction(new Function("BIN", 2, "Binomial Coefficient 'n choose k'") { @Override public MyComplex eval(List<MyComplex> parameters) { int n = (int) parameters.get(0).real; int k = (int) parameters.get(1).real; double d = CombinatoricsUtils.binomialCoefficientDouble(n, k); return new MyComplex(d); } }); addFunction(new Function("STIR", 2, "Stirling number of 2nd kind: http://mathworld.wolfram.com/StirlingNumberoftheSecondKind.html") { @Override public MyComplex eval(List<MyComplex> parameters) { int n = (int) parameters.get(0).real; int k = (int) parameters.get(1).real; double d = CombinatoricsUtils.stirlingS2(n, k); return new MyComplex(d); } }); addFunction(new Function("SIN", 1, "Sine function") { @Override public MyComplex eval(List<MyComplex> parameters) { return parameters.get(0).sin(); } }); addFunction(new Function("COS", 1, "Cosine function") { @Override public MyComplex eval(List<MyComplex> parameters) { return parameters.get(0).cos(); } }); addFunction(new Function("TAN", 1, "Tangent") { @Override public MyComplex eval(List<MyComplex> parameters) { return parameters.get(0).tan(); } }); addFunction(new Function("ASIN", 1, "Reverse Sine") { // added by av @Override public MyComplex eval(List<MyComplex> parameters) { return parameters.get(0).asin(); } }); addFunction(new Function("ACOS", 1, "Reverse Cosine") { // added by av @Override public MyComplex eval(List<MyComplex> parameters) { return parameters.get(0).acos(); } }); addFunction(new Function("ATAN", 1, "Reverse Tangent") { // added by av @Override public MyComplex eval(List<MyComplex> parameters) { return parameters.get(0).atan(); } }); addFunction(new Function("SINH", 1, "Hyperbolic Sine") { @Override public MyComplex eval(List<MyComplex> parameters) { return parameters.get(0).sinh(); } }); addFunction(new Function("COSH", 1, "Hyperbolic Cosine") { @Override public MyComplex eval(List<MyComplex> parameters) { return parameters.get(0).cosh(); } }); addFunction(new Function("TANH", 1, "Hyperbolic Tangent") { @Override public MyComplex eval(List<MyComplex> parameters) { return parameters.get(0).tanh(); } }); addFunction(new Function("RAD", 1, "Transform degree to radian") { @Override public MyComplex eval(List<MyComplex> parameters) { double d = Math.toRadians(parameters.get(0).real); return new MyComplex(d); } }); addFunction(new Function("DEG", 1, "Transform radian to degree") { @Override public MyComplex eval(List<MyComplex> parameters) { double d = Math.toDegrees(parameters.get(0).real); return new MyComplex(d); } }); addFunction(new Function("MAX", -1, "Find the biggest value in a list") { @Override public MyComplex eval(List<MyComplex> parameters) { MyComplex save = new MyComplex(Double.MIN_VALUE); if (parameters.size() == 0) { throw new ExpressionException("MAX requires at least one parameter"); } // if (parameters.get(0).type == ValueType.ARRAY) // parameters = parameters.get(0).list; if (parameters.get(0).type == ValueType.COMPLEX) { for (MyComplex parameter : parameters) { if (parameter.abs() > save.abs()) { save = parameter; } } save.type = ValueType.COMPLEX; } else { for (MyComplex parameter : parameters) { if (parameter.real > save.real) { save = parameter; } } save.type = ValueType.REAL; } return save; } }); /////////////////////////////////////////////////////// addFunction(new Function("IF", 3, "Conditional: give param3 if param1 is 0, otherwise param2") { @Override public MyComplex eval(List<MyComplex> parameters) { if (parameters.get(0).real == 0.0) { return parameters.get(2); } return parameters.get(1); } }); addFunction(new Function("PERC", 2, "Get param1 percent of param2") { @Override public MyComplex eval(List<MyComplex> parameters) { return parameters.get(0).divide(new MyComplex(100)).multiply(parameters.get(1)); } }); addFunction(new Function("PER", 2, "How many percent is param1 of param2") { @Override public MyComplex eval(List<MyComplex> parameters) { return parameters.get(0).multiply(new MyComplex(100)).divide(parameters.get(1)); } }); addFunction(new Function("H", 1, "Evaluate _history element") { @Override public MyComplex eval(List<MyComplex> parameters) { int i = (int) parameters.get(0).real; Expression ex = new Expression(history.get(i), history, mainVars); return ex.eval(); } }); addFunction(new Function("MERS", 1, "Calculate Mersenne Number") { @Override public MyComplex eval(List<MyComplex> parameters) { MyComplex p = parameters.get(0); return new MyComplex(2).pow(p).subtract(new MyComplex(1)); } }); addFunction(new Function("GCD", 2, "Find greatest common divisor of 2 values") { @Override public MyComplex eval(List<MyComplex> parameters) { double a = parameters.get(0).real; double b = parameters.get(1).real; long r = ArithmeticUtils.gcd((long) a, (long) b); return new MyComplex(r); } }); addFunction(new Function("LCM", 2, "Find least common multiple of 2 values") { @Override public MyComplex eval(List<MyComplex> parameters) { double a = parameters.get(0).real; double b = parameters.get(1).real; long r = ArithmeticUtils.lcm((long) a, (long) b); return new MyComplex(r); } }); addFunction(new Function("AMEAN", -1, "Arithmetic mean of a set of values") { @Override public MyComplex eval(List<MyComplex> parameters) { if (parameters.size() == 0) { throw new ExpressionException("MEAN requires at least one parameter"); } Mean m = new Mean(); double[] d = MyComplex.getRealArray(parameters); double d2 = m.evaluate(d); return new MyComplex(d2); } }); // addFunction(new Function("BYT", -1, // "Value from sequence of bytes") // { // @Override // public MyComplex eval (List<MyComplex> parameters) // { // if (parameters.size() == 0) // { // return MyComplex.ZERO; // } // BigInteger res = BigInteger.ZERO; // for (MyComplex parameter : parameters) // { // if (parameter.intValue() < 0 || parameter.intValue() > 255) // { // throw new ExpressionException("not a byte value"); // } // res = res.shiftLeft(8); // res = res.or(parameter.toBigInteger()); // } // return new MyComplex(res, BigInteger.ZERO); // } // }); addFunction(new Function("SEQ", 3, "Generate Sequence p1=start, p2=step, p3=count") { @Override public MyComplex eval(List<MyComplex> parameters) { double start = parameters.get(0).real; ArrayList<MyComplex> arr = new ArrayList<>(); for (int s = 0; s < (int) (parameters.get(2).real); s++) { arr.add(new MyComplex(start)); start += parameters.get(1).real; } return new MyComplex(arr); } }); addFunction(new Function("PROD", -1, "Product of real values") { @Override public MyComplex eval(List<MyComplex> parameters) { Product p = new Product(); double[] d = MyComplex.getRealArray(parameters); return new MyComplex(p.evaluate(d)); } }); addFunction(new Function("SUM", -1, "Sum of values") { @Override public MyComplex eval(List<MyComplex> parameters) { Sum p = new Sum(); double[] d = MyComplex.getRealArray(parameters); return new MyComplex(p.evaluate(d)); } }); addFunction(new Function("ANG", 1, "Angle phi of complex number in radians") { @Override public MyComplex eval(List<MyComplex> parameters) { double b = parameters.get(0).angle(); return new MyComplex(b); } }); addFunction(new Function("IM", 1, "Get imaginary part") { @Override public MyComplex eval(List<MyComplex> parameters) { return new MyComplex(parameters.get(0).imaginary); } }); addFunction(new Function("RE", 1, "Get real part") { @Override public MyComplex eval(List<MyComplex> parameters) { return new MyComplex(parameters.get(0).real); } }); addFunction(new Function("POL", 2, "Make complex number from polar coords. angle is first arg") { @Override public MyComplex eval(List<MyComplex> parameters) { double angle = parameters.get(0).real; double len = parameters.get(1).real; Complex c = ComplexUtils.polar2Complex(len, angle); return new MyComplex(c); } }); addFunction(new Function("GMEAN", -1, "Geometric mean of a set of values") { @Override public MyComplex eval(List<MyComplex> parameters) { if (parameters.size() == 0) { throw new ExpressionException("MEAN requires at least one parameter"); } GeometricMean m = new GeometricMean(); double[] d = MyComplex.getRealArray(parameters); double d2 = m.evaluate(d); return new MyComplex(d2); } }); addFunction(new Function("HMEAN", -1, "Harmonic mean of a set of values") { @Override public MyComplex eval(List<MyComplex> parameters) { if (parameters.size() == 0) { throw new ExpressionException("MEAN requires at least one parameter"); } MyComplex res = new MyComplex(0); int num = 0; for (MyComplex parameter : parameters) { res = res.add(new MyComplex(1).divide(parameter)); num++; } res = new MyComplex(res.abs()); return new MyComplex(num).divide(res); } }); addFunction(new Function("VAR", -1, "Variance of a set of values") { @Override public MyComplex eval(List<MyComplex> parameters) { if (parameters.size() == 0) { throw new ExpressionException("MEAN requires at least one parameter"); } double[] arr = new double[parameters.size()]; for (int s = 0; s < parameters.size(); s++) { arr[s] = parameters.get(s).real; } return new MyComplex(variance(arr)); } }); addFunction(new Function("NPR", 1, "Next prime number greater or equal the argument") { @Override public MyComplex eval(List<MyComplex> parameters) { return new MyComplex(nextPrime((int) parameters.get(0).real)); } }); addFunction(new Function("NSWP", 1, "Swap nibbles") { @Override public MyComplex eval(List<MyComplex> parameters) { BigInteger bi = parameters.get(0).toBigIntegerReal(); String s = bi.toString(16); s = new StringBuilder(s).reverse().toString(); return new MyComplex(new BigInteger(s, 16), BigInteger.ZERO); } }); addFunction(new Function("BSWP", 1, "Swap bytes") { @Override public MyComplex eval(List<MyComplex> parameters) { BigInteger bi = parameters.get(0).toBigIntegerReal(); String s = bi.toString(16); while (s.length() % 4 != 0) { s = s + "0"; } if (bi.intValue() < 256) { s = "00" + s; } s = Misc.reverseHex(s); return new MyComplex(new BigInteger(s, 16), BigInteger.ZERO); } }); addFunction(new Function("PYT", 2, "Pythagoras's result = sqrt(param1^2+param2^2) https://en.wikipedia.org/wiki/Pythagorean_theorem") { @Override public MyComplex eval(List<MyComplex> par) { double a = par.get(0).real; double b = par.get(1).real; return new MyComplex(Math.sqrt(a * a + b * b)); } }); addFunction(new Function("FIB", 1, "Fibonacci number") { // --Commented out by Inspection (2/19/2017 7:46 PM):private final Operator exp = operators.get("^"); @Override public MyComplex eval(List<MyComplex> par) { return Misc.iterativeFibonacci((int) par.get(0).real); } }); /////////////////////////////////////////////// addFunction(new Function("MIN", -1, "Find the smallest in a list of values") { @Override public MyComplex eval(List<MyComplex> parameters) { MyComplex save = new MyComplex(Double.MAX_VALUE); if (parameters.size() == 0) { throw new ExpressionException("MAX requires at least one parameter"); } if (parameters.get(0).type == ValueType.COMPLEX) { for (MyComplex parameter : parameters) { if (parameter.abs() < save.abs()) { save = parameter; } } save.type = ValueType.COMPLEX; } else { for (MyComplex parameter : parameters) { if (parameter.real < save.real) { save = parameter; } } save.type = ValueType.REAL; } return save; } }); addFunction(new Function("ABS", 1, "Get absolute value of a number") { @Override public MyComplex eval(List<MyComplex> parameters) { return new MyComplex(parameters.get(0).abs()); } }); addFunction(new Function("LN", 1, "Logarithm base e of the argument") { @Override public MyComplex eval(List<MyComplex> parameters) { double d = Math.log(parameters.get(0).real); return new MyComplex(d); } }); addFunction(new Function("LOG", 1, "Logarithm base 10 of the argument") { @Override public MyComplex eval(List<MyComplex> parameters) { double d = Math.log10(parameters.get(0).real); return new MyComplex(d); } }); addFunction(new Function("FLOOR", 1, "Rounds DOWN to nearest Integer") { @Override public MyComplex eval(List<MyComplex> parameters) { double d = Math.floor(parameters.get(0).real); return new MyComplex(d); } }); addFunction(new Function("CEIL", 1, "Rounds UP to nearest Integer") { @Override public MyComplex eval(List<MyComplex> parameters) { double d = Math.ceil(parameters.get(0).real); return new MyComplex(d); } }); addFunction(new Function("ROU", 1, "Rounds to nearest Integer") { @Override public MyComplex eval(List<MyComplex> parameters) { int d = (int) (parameters.get(0).real + 0.5); return new MyComplex(d); } }); addFunction(new Function("SQRT", 1, "Square root") { @Override public MyComplex eval(List<MyComplex> parameters) { MyComplex p = parameters.get(0); if (p.type == ValueType.REAL) { return new MyComplex(Math.sqrt(p.real)); } return p.sqrt(); } }); addFunction(new Function("ARR", -1, "Create array") { @Override public MyComplex eval(List<MyComplex> parameters) { return new MyComplex(parameters); } }); addFunction(new Function("POLY", -1, "Treat array as Polynom") { @Override public MyComplex eval(List<MyComplex> parameters) { double[] d = MyComplex.getRealArray(parameters); PolynomialFunction p = new PolynomialFunction(d); return new MyComplex(p); } }); addFunction(new Function("DRVE", -1, "Make derivative of polynomial") { @Override public MyComplex eval(List<MyComplex> parameters) { PolynomialFunction p; if (parameters.get(0).isPoly()) { p = new PolynomialFunction(parameters.get(0).getRealArray()); } else { double[] d = MyComplex.getRealArray(parameters); p = new PolynomialFunction(d); } return new MyComplex(p.polynomialDerivative()); } }); addFunction(new Function("ADRVE", -1, "Make antiderivative of polynomial. Constant is always zero") { @Override public MyComplex eval(List<MyComplex> parameters) { PolynomialFunction p; if (parameters.get(0).isPoly()) { p = new PolynomialFunction(parameters.get(0).getRealArray()); } else { double[] d = MyComplex.getRealArray(parameters); p = new PolynomialFunction(d); } return new MyComplex(Misc.antiDerive(p)); } }); addFunction(new Function("PVAL", 2, "Compute value of polynom for the given argument.") { @Override public MyComplex eval(List<MyComplex> parameters) { if (parameters.get(0).isPoly()) { PolynomialFunction p = new PolynomialFunction(parameters.get(0).getRealArray()); double v = p.value(parameters.get(1).real); return new MyComplex(v); } throw new ExpressionException("first arg must be polynomial"); } }); addFunction(new Function("INTGR", 3, "Numerical integration") { @Override public MyComplex eval(List<MyComplex> parameters) { if (parameters.get(0).isPoly()) { PolynomialFunction p = new PolynomialFunction(parameters.get(0).getRealArray()); double start = parameters.get(1).real; double end = parameters.get(2).real; SimpsonIntegrator si = new SimpsonIntegrator(); double d = si.integrate(1000, p, start, end); return new MyComplex(d); } throw new ExpressionException("first arg must be polynomial"); } }); }
From source file:com.itemanalysis.psychometrics.rasch.JMLE.java
/** * Run the primary JML estimation routines. * * To estimate thetas using known item parameters, the known parameters must be established and updateItems * should be set to false.//w w w. j av a2 s.co m * * Extreme persons and items are updated at the same time as nonextreme items and persons. However, the extreme * items and persons are not counted toward the convergence criterion and they are not used to estimate * parameters for the nonextreme items and persons. * * * @param globalMaxIter * @param globalConvergence maximum change in logits (LCONV in WINSTEPS documentation) * @param updateItems set to true if items are to be updated. Note individual items can be fixed too. * @throws SQLException */ public void update(int globalMaxIter, double globalConvergence, boolean updateItems, boolean updatePersons) { double DELTA = globalConvergence + 1.0; //LCONV maxDelta = new Max(); Mean itemMean = new Mean(); int iter = 0; RatingScaleItem rsi = null; RatingScaleThresholds rst = null; double newDifficulty = 0.0; while (DELTA >= globalConvergence && iter < globalMaxIter) { if (updateItems) { itemMean.clear(); //update items that are not fixed for (VariableName v : items.keySet()) { rsi = items.get(v); if (rsi.fixedParameter()) { itemMean.increment(rsi.getDifficulty()); } else { if (!rsi.extremeItem() && !rsi.droppedItem()) { newDifficulty = updateDifficulty(items.get(v), validRIS(rsi.getColumn()), vMPRIS(rsi.getColumn()), 0.0, DELTA); itemMean.increment(newDifficulty); } } } //update thresholds for (String s : thresholds.keySet()) { rst = thresholds.get(s); if (!rst.extremeThreshold() && !rst.fixedParameter()) updateThresholds(rst); } //accept new thresholds and increment delta. Only increments delta for non extreme categories for (String s : thresholds.keySet()) { maxDelta.increment(thresholds.get(s).acceptProposalThresholds()); } //Recenter proposal difficulties, accept proposal difficulties, and increment delta //Extreme items are not recentered, and their change in rho not counted in delta. for (VariableName v : items.keySet()) { rsi = items.get(v); if (!rsi.extremeItem() && !rsi.droppedItem()) { rsi.recenterProposalDifficulty(itemMean.getResult()); maxDelta.increment(rsi.acceptProposalDifficulty()); } /** * Set new threshold rho in RatingScaleItem object */ if (rsi.getNumberOfCategories() > 2) { rsi.setThresholds(thresholds.get(rsi.getGroupId()).getThresholds()); } } } //update persons //Change in person parameter is not counted toward delta. double tDelta = 0.0; if (updatePersons) { for (int i = 0; i < nPeople; i++) { if (!extremePersons[i]) { tDelta = updatePersons(i, validRawScore(data[i]), vMPRS(data[i]), DELTA); maxDelta.increment(tDelta); } } } DELTA = maxDelta.getResult(); maxDelta.clear(); iterationDelta.add(DELTA); //compute residuals for all nonextreme items completed by nonextreme examinees //the residual to compute are the expected score (TCC, iTCC) and observed score (RS, RIS) iter++; } //end JMLE loop }
From source file:com.itemanalysis.psychometrics.irt.estimation.JointMaximumLikelihoodEstimation.java
/** * Computes PROX difficulty estimates for item difficulty. These are used as starting values in JMLE. *///from w ww. jav a 2 s . c o m public void itemProx() { for (int j = 0; j < nItems; j++) { if (droppedStatus[j] == 0 && !irm[j].isFixed()) { double maxItemScore = itemSummary[j].maxSip(); double adjustedScore = itemSummary[j].Sip(); double p = adjustedScore / maxItemScore; double q = 1.0 - p; double prox = Math.log(q / p); irm[j].setDifficulty(prox); irm[j].setProposalDifficulty(prox); int ncat = irm[j].getNcat(); //threshold prox values if (ncat > 2) { double previous = 0.0; double current = 0.0; double[] threshold = new double[ncat - 1]; RaschRatingScaleGroup group = rsg.get(irm[j].getGroupId()); Mean tMean = new Mean(); for (int k = 0; k < ncat; k++) { current = group.SpjAt(k); if (k > 0) { threshold[k - 1] = Math.log(previous / current); tMean.increment(threshold[k - 1]); } previous = current; } for (int k = 0; k < ncat - 1; k++) { threshold[k] -= tMean.getResult(); } irm[j].setThresholdParameters(threshold); irm[j].setProposalThresholds(threshold); } } } }