private void doTextFieldActionPerformed(JTextField source) {
if (isUpdating) return;
try {
String inputText = source.getText().trim();
NumberValue nv;
nv = app.getKernel().getAlgebraProcessor().evaluateToNumeric(inputText, false);
double value = nv.getDouble();
if (source == fldXMin) {
settings.xMin = value;
firePropertyChange("settings", true, false);
} else if (source == fldXMax) {
settings.xMax = value;
firePropertyChange("settings", true, false);
} else if (source == fldYMax) {
settings.yMax = value;
firePropertyChange("settings", true, false);
} else if (source == fldYMin) {
settings.yMin = value;
firePropertyChange("settings", true, false);
} else if (source == fldXInterval) {
settings.xAxesInterval = value;
firePropertyChange("settings", true, false);
} else if (source == fldYInterval) {
settings.yAxesInterval = value;
firePropertyChange("settings", true, false);
}
} catch (NumberFormatException e) {
e.printStackTrace();
}
}
public AlgoIntegralFunctions(Construction cons, String label,
GeoFunction f, GeoFunction g,
NumberValue a, NumberValue b) {
super(cons);
this.f = f;
this.g = g;
this.a = a;
this.b = b;
ageo = a.toGeoElement();
bgeo = b.toGeoElement();
// helper algorithms for integral f and g
AlgoIntegralDefinite algoInt = new AlgoIntegralDefinite(cons, f, a, b);
cons.removeFromConstructionList(algoInt);
intF = algoInt.getIntegral();
algoInt = new AlgoIntegralDefinite(cons, g, a, b);
cons.removeFromConstructionList(algoInt);
intG = algoInt.getIntegral();
// output: intF - intG
n = new GeoNumeric(cons);
setInputOutput(); // for AlgoElement
compute();
n.setLabel(label);
}
/**
* Creates a new algorithm to create a sequence of objects that form a list.
*
* @param cons
* @param expression
* @param var
* @param var_from
* @param var_to
* @param var_step
*/
AlgoSequence(
Construction cons,
GeoElement expression,
GeoNumeric var,
NumberValue var_from,
NumberValue var_to,
NumberValue var_step) {
super(cons);
this.expression = expression;
this.var = var;
this.var_from = var_from;
var_from_geo = var_from.toGeoElement();
this.var_to = var_to;
var_to_geo = var_to.toGeoElement();
this.var_step = var_step;
if (var_step != null) var_step_geo = var_step.toGeoElement();
expressionParentAlgo = expression.getParentAlgorithm();
expIsFunctionOrCurve = expression.isGeoFunction() || expression.isGeoCurveCartesian();
// Application.debug("expression: " + expression);
// Application.debug(" parent algo: " + expression.getParentAlgorithm());
// // Application.debug(" parent algo input is var?: " +
// (expression.getParentAlgorithm().getInput()[0] == var));
// Application.debug(" variable: " + var);
// Application.debug(" expIsGeoFunction: " + expIsGeoFunction);
list = new GeoList(cons);
setInputOutput(); // for AlgoElement
compute();
}
private double evaluateExpression(String expr) {
NumberValue nv;
nv = kernel.getAlgebraProcessor().evaluateToNumeric(expr, false);
return nv.getDouble();
}
protected final void compute() {
// validate
size = inputList.size();
if (!inputList.isDefined() || size == 0) {
outputList.setUndefined();
return;
}
// convert geoList to sorted array of double
sortedData = new double[size];
for (int i = 0; i < size; i++) {
GeoElement geo = inputList.get(i);
if (geo.isNumberValue()) {
NumberValue num = (NumberValue) geo;
sortedData[i] = num.getDouble();
} else {
outputList.setUndefined();
return;
}
}
Arrays.sort(sortedData);
// create the z values
calculateZValues(size);
// prepare output list. Pre-existing geos will be recycled,
// but extra geos are removed when outputList is too long
outputList.setDefined(true);
for (int i = outputList.size() - 1; i >= size; i--) {
GeoElement extraGeo = outputList.get(i);
extraGeo.remove();
outputList.remove(extraGeo);
}
int oldListSize = outputList.size();
// iterate through the sorted data and create the normal quantile points
boolean suppressLabelCreation = cons.isSuppressLabelsActive();
cons.setSuppressLabelCreation(true);
for (int i = 0; i < sortedData.length; i++) {
if (i < oldListSize) ((GeoPoint) outputList.get(i)).setCoords(sortedData[i], zValues[i], 1.0);
else outputList.add(new GeoPoint(cons, null, sortedData[i], zValues[i], 1.0));
}
// create qq line segment and add it to the list
outputList.add(getQQLineSegment());
cons.setSuppressLabelCreation(suppressLabelCreation);
}
protected final void compute() {
if (!(f.isDefined() && ageo.isDefined() && bgeo.isDefined())) g.setUndefined();
// check if f has changed
if (!hasEqualExpressions(f, g)) {
g.set(f);
}
double ad = a.getDouble();
double bd = b.getDouble();
if (ad > bd) {
g.setUndefined();
} else {
boolean defined = g.setInterval(ad, bd);
g.setDefined(defined);
}
}
// for AlgoElement
protected void setInputOutput() {
input = new GeoElement[2];
input[0] = Ageo;
input[1] = angle.toGeoElement();
output = new GeoElement[1];
output[0] = Bgeo;
setDependencies(); // done by AlgoElement
}
/** Creates new AlgoDependentFunction */
public AlgoFunctionInterval(
Construction cons, String label, GeoFunction f, NumberValue a, NumberValue b) {
super(cons);
this.f = f;
this.a = a;
this.b = b;
ageo = a.toGeoElement();
bgeo = b.toGeoElement();
// g = new GeoFunction(cons); // output
// g = new GeoFunction(cons); // output
g = (GeoFunction) f.copyInternal(cons);
// buildFunction();
// g = initHelperAlgorithm();
setInputOutput(); // for AlgoElement
compute();
g.setLabel(label);
}
protected final void compute() {
if (updateRunning) return;
updateRunning = true;
for (int i = 1; i < input.length; i++) {
if (!input[i].isDefined()) {
list.setUndefined();
updateRunning = false;
return;
}
}
list.setDefined(true);
// create sequence for expression(var) by changing var according to the given range
double from = var_from.getDouble();
double to = var_to.getDouble();
double step = var_step == null ? 1 : var_step.getDouble();
isEmpty = !((to - from) * step > -Kernel.MIN_PRECISION);
// an update may be necessary because another variable in expression
// has changed. However, the range (from, to, step) may not have changed:
// in this case it is much more efficient not to create all objects
// for the list again, but just to set their new values
boolean setValuesOnly = (from == last_from && to == last_to && step == last_step);
// setValues does not work for functions
setValuesOnly = setValuesOnly && !expIsFunctionOrCurve;
// avoid label creation, might happen e.g. in
boolean oldSuppressLabels = cons.isSuppressLabelsActive();
cons.setSuppressLabelCreation(true);
// update list
if (setValuesOnly) updateListItems(from, to, step);
else createNewList(from, to, step);
// revert label creation setting
cons.setSuppressLabelCreation(oldSuppressLabels);
updateRunning = false;
}
AlgoRotate(Construction cons, Rotateable A, NumberValue angle) {
super(cons);
this.angle = angle;
Ageo = A.toGeoElement();
angleGeo = angle.toGeoElement();
// create output object
Bgeo = Ageo.copy();
B = (Rotateable) Bgeo;
setInputOutput();
cons.registerEuclidianViewAlgo(this);
compute();
}
public AlgoIntegralFunctions copy(){
return new AlgoIntegralFunctions(cons, null, (GeoFunction)f.copy(),(GeoFunction)g.copy(),
new MyDouble(kernel,a.getDouble()), new MyDouble(kernel,b.getDouble()));
}