code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
public static SVGPath drawFakeVoronoi(Projection2D proj, List<double[]> means) {
CanvasSize viewport = proj.estimateViewport();
final SVGPath path = new SVGPath();
// Difference
final double[] dirv = VMath.minus(means.get(1), means.get(0));
VMath.rotate90Equals(dirv);
double[] dir = proj.fastProjectRelativeDataToRenderSpace(dirv);
// Mean
final double[] mean = VMath.plus(means.get(0), means.get(1));
VMath.timesEquals(mean, 0.5);
double[] projmean = proj.fastProjectDataToRenderSpace(mean);
double factor = viewport.continueToMargin(projmean, dir);
path.moveTo(projmean[0] + factor * dir[0], projmean[1] + factor * dir[1]);
// Inverse direction:
dir[0] *= -1;
dir[1] *= -1;
factor = viewport.continueToMargin(projmean, dir);
path.drawTo(projmean[0] + factor * dir[0], projmean[1] + factor * dir[1]);
return path;
} | java |
public void select(Segment segment, boolean addToSelection) {
// abort if segment represents pairs inNone. Would select all segments...
if(segment.isNone()) {
return;
}
if(!addToSelection) {
deselectAllSegments();
}
// get selected segments
if(segment.isUnpaired()) {
// check if all segments are selected
if(addToSelection) {
boolean allSegmentsSelected = true;
for(Segment other : segments.getPairedSegments(segment)) {
if(!isSelected(other)) {
allSegmentsSelected = false;
break;
}
}
// if all are selected, deselect all
if(allSegmentsSelected) {
deselectSegment(segment);
return;
}
}
if(isSelected(segment)) {
deselectSegment(segment);
}
else {
selectSegment(segment);
}
}
else {
// an object segment was selected
if(isSelected(segment)) {
deselectSegment(segment);
}
else {
selectSegment(segment);
}
}
} | java |
protected void deselectSegment(Segment segment) {
if(segment.isUnpaired()) {
ArrayList<Segment> remove = new ArrayList<>();
// remove all object segments associated with unpaired segment from
// selection list
for(Entry<Segment, Segment> entry : indirectSelections.entrySet()) {
if(entry.getValue() == segment) {
remove.add(entry.getKey());
}
}
for(Segment other : remove) {
indirectSelections.remove(other);
deselectSegment(other);
}
}
else {
// check if deselected object Segment has a unpaired segment highlighted
Segment unpaired = indirectSelections.get(segment);
if(unpaired != null) {
// remove highlight
deselectSegment(unpaired);
}
if(selectedSegments.remove(segment) && segment.getDBIDs() != null) {
unselectedObjects.addDBIDs(segment.getDBIDs());
}
}
} | java |
protected void selectSegment(Segment segment) {
if(segment.isUnpaired()) {
// remember selected unpaired segment
for(Segment other : segments.getPairedSegments(segment)) {
indirectSelections.put(other, segment);
selectSegment(other);
}
}
else {
if(!selectedSegments.contains(segment)) {
selectedSegments.add(segment);
if(segment.getDBIDs() != null) {
unselectedObjects.removeDBIDs(segment.getDBIDs());
}
}
}
} | java |
private boolean checkSupertypes(Class<?> cls) {
for(Class<?> c : knownParameterizables) {
if(c.isAssignableFrom(cls)) {
return true;
}
}
return false;
} | java |
private State checkV3Parameterization(Class<?> cls, State state) throws NoClassDefFoundError {
// check for a V3 Parameterizer class
for(Class<?> inner : cls.getDeclaredClasses()) {
if(AbstractParameterizer.class.isAssignableFrom(inner)) {
try {
Class<? extends AbstractParameterizer> pcls = inner.asSubclass(AbstractParameterizer.class);
pcls.newInstance();
if(checkParameterizer(cls, pcls)) {
if(state == State.INSTANTIABLE) {
LOG.warning("More than one parameterization method in class " + cls.getName());
}
state = State.INSTANTIABLE;
}
}
catch(Exception|Error e) {
LOG.verbose("Could not run Parameterizer: " + inner.getName() + ": " + e.getMessage());
// continue. Probably non-public
}
}
}
return state;
} | java |
private State checkDefaultConstructor(Class<?> cls, State state) throws NoClassDefFoundError {
try {
cls.getConstructor();
return State.DEFAULT_INSTANTIABLE;
}
catch(Exception e) {
// do nothing.
}
return state;
} | java |
public static double logpdf(double x, double k, double theta, double shift) {
x = (x - shift);
if(x <= 0.) {
return Double.NEGATIVE_INFINITY;
}
final double log1px = FastMath.log1p(x);
return k * FastMath.log(theta) - GammaDistribution.logGamma(k) - (theta + 1.) * log1px + (k - 1) * FastMath.log(log1px);
} | java |
protected void plotGray(SVGPlot plot, Element parent, double x, double y, double size) {
Element marker = plot.svgCircle(x, y, size * .5);
SVGUtil.setStyle(marker, SVGConstants.CSS_FILL_PROPERTY + ":" + greycolor);
parent.appendChild(marker);
} | java |
protected void plotUncolored(SVGPlot plot, Element parent, double x, double y, double size) {
Element marker = plot.svgCircle(x, y, size * .5);
SVGUtil.setStyle(marker, SVGConstants.CSS_FILL_PROPERTY + ":" + dotcolor);
parent.appendChild(marker);
} | java |
public int truePositives() {
int tp = 0;
for(int i = 0; i < confusion.length; i++) {
tp += truePositives(i);
}
return tp;
} | java |
public int trueNegatives(int classindex) {
int tn = 0;
for(int i = 0; i < confusion.length; i++) {
for(int j = 0; j < confusion[i].length; j++) {
if(i != classindex && j != classindex) {
tn += confusion[i][j];
}
}
}
return tn;
} | java |
public int falsePositives(int classindex) {
int fp = 0;
for(int i = 0; i < confusion[classindex].length; i++) {
if(i != classindex) {
fp += confusion[classindex][i];
}
}
return fp;
} | java |
public int falseNegatives(int classindex) {
int fn = 0;
for(int i = 0; i < confusion.length; i++) {
if(i != classindex) {
fn += confusion[i][classindex];
}
}
return fn;
} | java |
public int totalInstances() {
int total = 0;
for(int i = 0; i < confusion.length; i++) {
for(int j = 0; j < confusion[i].length; j++) {
total += confusion[i][j];
}
}
return total;
} | java |
protected static <A> double[] computeDistances(NumberArrayAdapter<?, A> adapter, A data) {
final int size = adapter.size(data);
double[] dMatrix = new double[(size * (size + 1)) >> 1];
for(int i = 0, c = 0; i < size; i++) {
for(int j = 0; j < i; j++) {
double dx = adapter.getDouble(data, i) - adapter.getDouble(data, j);
dMatrix[c++] = (dx < 0) ? -dx : dx; // Absolute difference.
}
c++; // Diagonal entry: zero
}
doubleCenterMatrix(dMatrix, size);
return dMatrix;
} | java |
public static void doubleCenterMatrix(double[] dMatrix, int size) {
double[] rowMean = new double[size];
// row sum
for(int i = 0, c = 0; i < size; i++) {
for(int j = 0; j < i; j++) {
double v = dMatrix[c++];
rowMean[i] += v;
rowMean[j] += v;
}
assert (dMatrix[c] == 0.);
c++; // Diagonal entry. Must be zero!
}
// Normalize averages:
double matrixMean = 0.;
for(int i = 0; i < size; i++) {
matrixMean += rowMean[i];
rowMean[i] /= size;
}
matrixMean /= size * size;
for(int o = 0, c = 0; o < size; o++) {
// Including row mean!
for(int p = 0; p <= o; p++) {
dMatrix[c++] -= rowMean[o] + rowMean[p] - matrixMean;
}
}
} | java |
public HyperBoundingBox determineAlphaMinMax(HyperBoundingBox interval) {
final int dim = vec.getDimensionality();
if(interval.getDimensionality() != dim - 1) {
throw new IllegalArgumentException("Interval needs to have dimensionality d=" + (dim - 1) + ", read: " + interval.getDimensionality());
}
if(extremumType.equals(ExtremumType.CONSTANT)) {
double[] centroid = SpatialUtil.centroid(interval);
return new HyperBoundingBox(centroid, centroid);
}
double[] alpha_min = new double[dim - 1];
double[] alpha_max = new double[dim - 1];
if(SpatialUtil.contains(interval, alphaExtremum)) {
if(extremumType.equals(ExtremumType.MINIMUM)) {
alpha_min = alphaExtremum;
for(int d = dim - 2; d >= 0; d--) {
alpha_max[d] = determineAlphaMax(d, alpha_max, interval);
}
}
else {
alpha_max = alphaExtremum;
for(int d = dim - 2; d >= 0; d--) {
alpha_min[d] = determineAlphaMin(d, alpha_min, interval);
}
}
}
else {
for(int d = dim - 2; d >= 0; d--) {
alpha_min[d] = determineAlphaMin(d, alpha_min, interval);
alpha_max[d] = determineAlphaMax(d, alpha_max, interval);
}
}
return new HyperBoundingBox(alpha_min, alpha_max);
} | java |
private ExtremumType extremumType(int n, double[] alpha_extreme, HyperBoundingBox interval) {
// return the type of the global extremum
if(n == alpha_extreme.length - 1) {
return extremumType;
}
// create random alpha values
double[] alpha_extreme_l = new double[alpha_extreme.length];
double[] alpha_extreme_r = new double[alpha_extreme.length];
double[] alpha_extreme_c = new double[alpha_extreme.length];
System.arraycopy(alpha_extreme, 0, alpha_extreme_l, 0, alpha_extreme.length);
System.arraycopy(alpha_extreme, 0, alpha_extreme_r, 0, alpha_extreme.length);
System.arraycopy(alpha_extreme, 0, alpha_extreme_c, 0, alpha_extreme.length);
double[] centroid = SpatialUtil.centroid(interval);
for(int i = 0; i < n; i++) {
alpha_extreme_l[i] = centroid[i];
alpha_extreme_r[i] = centroid[i];
alpha_extreme_c[i] = centroid[i];
}
double intervalLength = interval.getMax(n) - interval.getMin(n);
alpha_extreme_l[n] = Math.random() * intervalLength + interval.getMin(n);
alpha_extreme_r[n] = Math.random() * intervalLength + interval.getMin(n);
double f_c = function(alpha_extreme_c);
double f_l = function(alpha_extreme_l);
double f_r = function(alpha_extreme_r);
if(f_l < f_c) {
if(f_r < f_c || Math.abs(f_r - f_c) < DELTA) {
return ExtremumType.MAXIMUM;
}
}
if(f_r < f_c) {
if(f_l < f_c || Math.abs(f_l - f_c) < DELTA) {
return ExtremumType.MAXIMUM;
}
}
if(f_l > f_c) {
if(f_r > f_c || Math.abs(f_r - f_c) < DELTA) {
return ExtremumType.MINIMUM;
}
}
if(f_r > f_c) {
if(f_l > f_c || Math.abs(f_l - f_c) < DELTA) {
return ExtremumType.MINIMUM;
}
}
if(Math.abs(f_l - f_c) < DELTA && Math.abs(f_r - f_c) < DELTA) {
return ExtremumType.CONSTANT;
}
throw new IllegalArgumentException("Houston, we have a problem!\n" + this + //
"\nf_l " + f_l + "\nf_c " + f_c + "\nf_r " + f_r + "\np " + vec + //
"\nalpha " + FormatUtil.format(alpha_extreme_c) + //
"\nalpha_l " + FormatUtil.format(alpha_extreme_l) + //
"\nalpha_r " + FormatUtil.format(alpha_extreme_r) + "\nn " + n);
// + "box min " + FormatUtil.format(interval.getMin()) + "\n"
// + "box max " + FormatUtil.format(interval.getMax()) + "\n"
} | java |
private double determineAlphaMin(int n, double[] alpha_min, HyperBoundingBox interval) {
double alpha_n = extremum_alpha_n(n, alpha_min);
double lower = interval.getMin(n);
double upper = interval.getMax(n);
double[] alpha_extreme = new double[alpha_min.length];
System.arraycopy(alpha_min, n, alpha_extreme, n, alpha_extreme.length - n);
alpha_extreme[n] = alpha_n;
ExtremumType type = extremumType(n, alpha_extreme, interval);
if(type.equals(ExtremumType.MINIMUM) || type.equals(ExtremumType.CONSTANT)) {
// A) lower <= alpha_n <= upper
if(lower <= alpha_n && alpha_n <= upper) {
return alpha_n;
}
// B) alpha_n < upper
else if(alpha_n < lower) {
return lower;
}
// C) alpha_n > max
else {
if(alpha_n <= upper) {
throw new IllegalStateException("Should never happen!");
}
return upper;
}
}
// extremum is maximum
else {
if(lower <= alpha_n && alpha_n <= upper) {
// A1) min <= alpha_n <= max && alpha_n - min <= max - alpha_n
if(alpha_n - lower <= upper - alpha_n) {
return upper;
}
// A2) min <= alpha_n <= max && alpha_n - min > max - alpha_n
else {
return lower;
}
}
// B) alpha_n < min
else if(alpha_n < lower) {
return upper;
}
// C) alpha_n > max
else {
if(alpha_n <= upper) {
throw new IllegalStateException("Should never happen!");
}
return lower;
}
}
} | java |
public static double sinusProduct(int start, int end, double[] alpha) {
double result = 1;
for(int j = start; j < end; j++) {
result *= FastMath.sin(alpha[j]);
}
return result;
} | java |
private void determineGlobalExtremum() {
alphaExtremum = new double[vec.getDimensionality() - 1];
for(int n = alphaExtremum.length - 1; n >= 0; n--) {
alphaExtremum[n] = extremum_alpha_n(n, alphaExtremum);
if(Double.isNaN(alphaExtremum[n])) {
throw new IllegalStateException("Houston, we have a problem!\n" + this + "\n" + vec + "\n" + FormatUtil.format(alphaExtremum));
}
}
determineGlobalExtremumType();
} | java |
private void determineGlobalExtremumType() {
final double f = function(alphaExtremum);
// create random alpha values
double[] alpha_1 = new double[alphaExtremum.length];
double[] alpha_2 = new double[alphaExtremum.length];
for(int i = 0; i < alphaExtremum.length; i++) {
alpha_1[i] = Math.random() * Math.PI;
alpha_2[i] = Math.random() * Math.PI;
}
// look if f1 and f2 are less, greater or equal to f
double f1 = function(alpha_1);
double f2 = function(alpha_2);
if(f1 < f && f2 < f) {
extremumType = ExtremumType.MAXIMUM;
}
else if(f1 > f && f2 > f) {
extremumType = ExtremumType.MINIMUM;
}
else if(Math.abs(f1 - f) < DELTA && Math.abs(f2 - f) < DELTA) {
extremumType = ExtremumType.CONSTANT;
}
else {
throw new IllegalStateException("Houston, we have a problem:" + "\n" + this + "\nextremum at " + FormatUtil.format(alphaExtremum) + "\nf " + f + "\nf1 " + f1 + "\nf2 " + f2);
}
} | java |
public void setParameters(Parameterization config) {
TrackParameters track = new TrackParameters(config);
configureStep(track);
// update parameter table
{
parameterTable.setEnabled(false);
parameterTable.clear();
for(TrackedParameter pair : track.getAllParameters()) {
parameterTable.addParameter(pair.getOwner(), pair.getParameter(), track);
}
// parameters.updateFromTrackParameters(track);
parameterTable.revalidate();
parameterTable.setEnabled(true);
}
// Update status and notify observers
updateStatus();
firePanelUpdated();
} | java |
protected void reportErrors(Parameterization config) {
StringBuilder buf = new StringBuilder();
for(ParameterException e : config.getErrors()) {
if(e instanceof UnspecifiedParameterException) {
continue;
}
buf.append(e.getMessage()).append(FormatUtil.NEWLINE);
}
if(buf.length() > 0) {
LOG.warning("Configuration errors:" + FormatUtil.NEWLINE + FormatUtil.NEWLINE + buf.toString());
}
// config.clearErrors();
} | java |
public boolean canRun() {
Status status = getStatus();
return Status.STATUS_READY.equals(status) || Status.STATUS_COMPLETE.equals(status);
} | java |
public SVGPath lineTo(double x, double y) {
return append(PATH_LINE_TO).append(x).append(y);
} | java |
public SVGPath relativeLineTo(double x, double y) {
return append(PATH_LINE_TO_RELATIVE).append(x).append(y);
} | java |
public SVGPath moveTo(double x, double y) {
return append(PATH_MOVE).append(x).append(y);
} | java |
public SVGPath relativeMoveTo(double x, double y) {
return append(PATH_MOVE_RELATIVE).append(x).append(y);
} | java |
public SVGPath smoothQuadTo(double x, double y) {
return append(PATH_SMOOTH_QUAD_TO).append(x).append(y);
} | java |
public SVGPath relativeSmoothQuadTo(double x, double y) {
return append(PATH_SMOOTH_QUAD_TO_RELATIVE).append(x).append(y);
} | java |
private SVGPath append(char action) {
assert lastaction != 0 || action == PATH_MOVE : "Paths must begin with a move to the initial position!";
if(lastaction != action) {
buf.append(action);
lastaction = action;
}
return this;
} | java |
private SVGPath append(double x) {
if(!Double.isFinite(x)) {
throw new IllegalArgumentException("Cannot draw an infinite/NaN position.");
}
if(x >= 0) {
final int l = buf.length();
if(l > 0) {
char c = buf.charAt(l - 1);
assert c != 'e' && c != 'E' : "Invalid exponential in path";
if(c >= '0' && c <= '9')
buf.append(' ');
}
}
buf.append(SVGUtil.FMT.format(x));
return this;
} | java |
public SVGPath close() {
assert lastaction != 0 : "Paths must begin with a move to the initial position!";
if(lastaction != PATH_CLOSE) {
buf.append(' ').append(PATH_CLOSE);
lastaction = PATH_CLOSE;
}
return this;
} | java |
public Element makeElement(SVGPlot plot) {
Element elem = plot.svgElement(SVGConstants.SVG_PATH_TAG);
elem.setAttribute(SVGConstants.SVG_D_ATTRIBUTE, buf.toString());
return elem;
} | java |
public void setParameters(Parameterization config) {
// Clear errors after each step, so they don't consider themselves failed
// because of earlier errors.
logTab.setParameters(config);
// config.clearErrors();
inputTab.setParameters(config);
// config.clearErrors();
algTab.setParameters(config);
// config.clearErrors();
evalTab.setParameters(config);
// config.clearErrors();
outTab.setParameters(config);
// config.clearErrors();
} | java |
public ArrayList<String> serializeParameters() {
ListParameterization params = new ListParameterization();
logTab.appendParameters(params);
inputTab.appendParameters(params);
algTab.appendParameters(params);
evalTab.appendParameters(params);
outTab.appendParameters(params);
return params.serialize();
} | java |
public static void main(final String[] args) {
GUIUtil.logUncaughtExceptions(LOG);
GUIUtil.setLookAndFeel();
OutputStep.setDefaultHandlerVisualizer();
javax.swing.SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
try {
final MultiStepGUI gui = new MultiStepGUI();
gui.run();
if(args != null && args.length > 0) {
gui.setParameters(new SerializedParameterization(args));
}
else {
gui.setParameters(new SerializedParameterization());
}
}
catch(Exception | Error e) {
// Restore error handler, as the GUI is likely broken.
LoggingConfiguration.replaceDefaultHandler(new CLISmartHandler());
LOG.exception(e);
}
}
});
} | java |
protected static boolean match(Object ref, Object test) {
if(ref == null) {
return false;
}
// Cheap and fast, may hold for class labels!
if(ref == test) {
return true;
}
if(ref instanceof LabelList && test instanceof LabelList) {
final LabelList lref = (LabelList) ref;
final LabelList ltest = (LabelList) test;
final int s1 = lref.size(), s2 = ltest.size();
if(s1 == 0 || s2 == 0) {
return false;
}
for(int i = 0; i < s1; i++) {
String l1 = lref.get(i);
if(l1 == null) {
continue;
}
for(int j = 0; j < s2; j++) {
if(l1.equals(ltest.get(j))) {
return true;
}
}
}
}
// Fallback to equality, e.g. on class labels
return ref.equals(test);
} | java |
private void findMatches(ModifiableDBIDs posn, Relation<?> lrelation, Object label) {
posn.clear();
for(DBIDIter ri = lrelation.iterDBIDs(); ri.valid(); ri.advance()) {
if(match(label, lrelation.get(ri))) {
posn.add(ri);
}
}
} | java |
private void computeDistances(ModifiableDoubleDBIDList nlist, DBIDIter query, final DistanceQuery<O> distQuery, Relation<O> relation) {
nlist.clear();
O qo = relation.get(query);
for(DBIDIter ri = relation.iterDBIDs(); ri.valid(); ri.advance()) {
if(!includeSelf && DBIDUtil.equal(ri, query)) {
continue;
}
double dist = distQuery.distance(qo, ri);
if(dist != dist) { /* NaN */
dist = Double.POSITIVE_INFINITY;
}
nlist.add(dist, ri);
}
nlist.sort();
} | java |
private PrintStream newStream(String name) throws IOException {
if(LOG.isDebuggingFiner()) {
LOG.debugFiner("Requested stream: " + name);
}
// Ensure the directory exists:
if(!basename.exists()) {
basename.mkdirs();
}
String fn = basename.getAbsolutePath() + File.separator + name + EXTENSION;
fn = usegzip ? fn + GZIP_EXTENSION : fn;
OutputStream os = new FileOutputStream(fn);
if(usegzip) {
// wrap into gzip stream.
os = new GZIPOutputStream(os);
}
PrintStream res = new PrintStream(os);
if(LOG.isDebuggingFiner()) {
LOG.debugFiner("Opened new output stream:" + fn);
}
// cache.
return res;
} | java |
protected <N extends Page & Externalizable> PageFile<N> makePageFile(Class<N> cls) {
@SuppressWarnings("unchecked")
final PageFileFactory<N> castFactory = (PageFileFactory<N>) pageFileFactory;
return castFactory.newPageFile(cls);
} | java |
public static boolean isAngularDistance(AbstractMaterializeKNNPreprocessor<?> kNN) {
DistanceFunction<?> distanceFunction = kNN.getDistanceQuery().getDistanceFunction();
return CosineDistanceFunction.class.isInstance(distanceFunction) //
|| ArcCosineDistanceFunction.class.isInstance(distanceFunction);
} | java |
public static Element drawCosine(SVGPlot svgp, Projection2D proj, NumberVector mid, double angle) {
// Project origin
double[] pointOfOrigin = proj.fastProjectDataToRenderSpace(new double[proj.getInputDimensionality()]);
// direction of the selected Point
double[] selPoint = proj.fastProjectDataToRenderSpace(mid);
double[] range1, range2;
{
// Rotation plane:
double[] pm = mid.toArray();
// Compute relative vectors
double[] p1 = minusEquals(proj.fastProjectRenderToDataSpace(selPoint[0] + 10, selPoint[1]), pm);
double[] p2 = minusEquals(proj.fastProjectRenderToDataSpace(selPoint[0], selPoint[1] + 10), pm);
// Scale p1 and p2 to unit length:
timesEquals(p1, 1. / euclideanLength(p1));
timesEquals(p2, 1. / euclideanLength(p2));
if(Math.abs(scalarProduct(p1, p2)) > 1E-10) {
LoggingUtil.warning("Projection does not seem to be orthogonal?");
}
// Project onto p1, p2:
double l1 = scalarProduct(pm, p1), l2 = scalarProduct(pm, p2);
// Rotate projection by + and - angle
// Using sin(-x) = -sin(x) and cos(-x)=cos(x)
final DoubleWrapper tmp = new DoubleWrapper(); // To return cosine
final double sangle = FastMath.sinAndCos(angle, tmp), cangle = tmp.value;
double r11 = +cangle * l1 - sangle * l2, r12 = +sangle * l1 + cangle * l2;
double r21 = +cangle * l1 + sangle * l2, r22 = -sangle * l1 + cangle * l2;
// Build rotated vectors - remove projected component, add rotated
// component:
double[] r1 = plusTimesEquals(plusTimes(pm, p1, -l1 + r11), p2, -l2 + r12);
double[] r2 = plusTimesEquals(plusTimes(pm, p1, -l1 + r21), p2, -l2 + r22);
// Project to render space:
range1 = proj.fastProjectDataToRenderSpace(r1);
range2 = proj.fastProjectDataToRenderSpace(r2);
}
// Continue lines to viewport.
{
CanvasSize viewport = proj.estimateViewport();
minusEquals(range1, pointOfOrigin);
plusEquals(timesEquals(range1, viewport.continueToMargin(pointOfOrigin, range1)), pointOfOrigin);
minusEquals(range2, pointOfOrigin);
plusEquals(timesEquals(range2, viewport.continueToMargin(pointOfOrigin, range2)), pointOfOrigin);
// Go backwards into the other direction - the origin might not be in the
// viewport!
double[] start1 = minus(pointOfOrigin, range1);
plusEquals(timesEquals(start1, viewport.continueToMargin(range1, start1)), range1);
double[] start2 = minus(pointOfOrigin, range2);
plusEquals(timesEquals(start2, viewport.continueToMargin(range2, start2)), range2);
// TODO: add filled variant?
return new SVGPath().moveTo(start1).lineTo(range1).moveTo(start2).lineTo(range2).makeElement(svgp);
}
} | java |
public void splitupNoSort(ArrayModifiableDBIDs ind, int begin, int end, int dim, Random rand) {
final int nele = end - begin;
dim = dim % projectedPoints.length;// choose a projection of points
DoubleDataStore tpro = projectedPoints[dim];
// save set such that used for density or neighborhood computation
// sets should be roughly minSplitSize
if(nele > minSplitSize * (1 - sizeTolerance) && nele < minSplitSize * (1 + sizeTolerance)) {
// sort set, since need median element later
ind.sort(begin, end, new DataStoreUtil.AscendingByDoubleDataStore(tpro));
splitsets.add(DBIDUtil.newArray(ind.slice(begin, end)));
}
// compute splitting element
// do not store set or even sort set, since it is too large
if(nele > minSplitSize) {
// splits can be performed either by distance (between min,maxCoord) or by
// picking a point randomly(picking index of point)
// outcome is similar
// int minInd splitByDistance(ind, nele, tpro);
int minInd = splitRandomly(ind, begin, end, tpro, rand);
// split set recursively
// position used for splitting the projected points into two
// sets used for recursive splitting
int splitpos = minInd + 1;
splitupNoSort(ind, begin, splitpos, dim + 1, rand);
splitupNoSort(ind, splitpos, end, dim + 1, rand);
}
} | java |
public int splitRandomly(ArrayModifiableDBIDs ind, int begin, int end, DoubleDataStore tpro, Random rand) {
final int nele = end - begin;
DBIDArrayIter it = ind.iter();
// pick random splitting element based on position
double rs = tpro.doubleValue(it.seek(begin + rand.nextInt(nele)));
int minInd = begin, maxInd = end - 1;
// permute elements such that all points smaller than the splitting
// element are on the right and the others on the left in the array
while(minInd < maxInd) {
double currEle = tpro.doubleValue(it.seek(minInd));
if(currEle > rs) {
while(minInd < maxInd && tpro.doubleValue(it.seek(maxInd)) > rs) {
maxInd--;
}
if(minInd == maxInd) {
break;
}
ind.swap(minInd, maxInd);
maxInd--;
}
minInd++;
}
// if all elements are the same split in the middle
if(minInd == end - 1) {
minInd = (begin + end) >>> 1;
}
return minInd;
} | java |
public int splitByDistance(ArrayModifiableDBIDs ind, int begin, int end, DoubleDataStore tpro, Random rand) {
DBIDArrayIter it = ind.iter();
// pick random splitting point based on distance
double rmin = Double.MAX_VALUE * .5, rmax = -Double.MAX_VALUE * .5;
int minInd = begin, maxInd = end - 1;
for(it.seek(begin); it.getOffset() < end; it.advance()) {
double currEle = tpro.doubleValue(it);
rmin = Math.min(currEle, rmin);
rmax = Math.max(currEle, rmax);
}
if(rmin != rmax) { // if not all elements are the same
double rs = rmin + rand.nextDouble() * (rmax - rmin);
// permute elements such that all points smaller than the splitting
// element are on the right and the others on the left in the array
while(minInd < maxInd) {
double currEle = tpro.doubleValue(it.seek(minInd));
if(currEle > rs) {
while(minInd < maxInd && tpro.doubleValue(it.seek(maxInd)) > rs) {
maxInd--;
}
if(minInd == maxInd) {
break;
}
ind.swap(minInd, maxInd);
maxInd--;
}
minInd++;
}
}
else {
// if all elements are the same split in the middle
minInd = (begin + end) >>> 1;
}
return minInd;
} | java |
public DataStore<? extends DBIDs> getNeighs() {
final DBIDs ids = points.getDBIDs();
// init lists
WritableDataStore<ModifiableDBIDs> neighs = DataStoreUtil.makeStorage(ids, DataStoreFactory.HINT_HOT, ModifiableDBIDs.class);
for(DBIDIter it = ids.iter(); it.valid(); it.advance()) {
neighs.put(it, DBIDUtil.newHashSet());
}
FiniteProgress splitp = LOG.isVerbose() ? new FiniteProgress("Processing splits for neighborhoods", splitsets.size(), LOG) : null;
// go through all sets
Iterator<ArrayDBIDs> it1 = splitsets.iterator();
DBIDVar v = DBIDUtil.newVar();
while(it1.hasNext()) {
ArrayDBIDs pinSet = it1.next();
final int indoff = pinSet.size() >> 1; // middle point of projection
pinSet.assignVar(indoff, v);
// add all points as neighbors to middle point
neighs.get(v).addDBIDs(pinSet);
// and the the middle point to all other points in set
for(DBIDIter it = pinSet.iter(); it.valid(); it.advance()) {
neighs.get(it).add(v);
}
LOG.incrementProcessed(splitp);
}
LOG.ensureCompleted(splitp);
return neighs;
} | java |
public DoubleDataStore computeAverageDistInSet() {
WritableDoubleDataStore davg = DataStoreUtil.makeDoubleStorage(points.getDBIDs(), DataStoreFactory.HINT_HOT);
WritableIntegerDataStore nDists = DataStoreUtil.makeIntegerStorage(points.getDBIDs(), DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_TEMP);
FiniteProgress splitp = LOG.isVerbose() ? new FiniteProgress("Processing splits for density estimation", splitsets.size(), LOG) : null;
DBIDVar v = DBIDUtil.newVar();
for(Iterator<ArrayDBIDs> it1 = splitsets.iterator(); it1.hasNext();) {
ArrayDBIDs pinSet = it1.next();
final int len = pinSet.size();
final int indoff = len >> 1;
pinSet.assignVar(indoff, v);
V midpoint = points.get(v);
for(DBIDArrayIter it = pinSet.iter(); it.getOffset() < len; it.advance()) {
if(DBIDUtil.equal(it, v)) {
continue;
}
double dist = EuclideanDistanceFunction.STATIC.distance(points.get(it), midpoint);
++distanceComputations;
davg.increment(v, dist);
nDists.increment(v, 1);
davg.increment(it, dist);
nDists.increment(it, 1);
}
LOG.incrementProcessed(splitp);
}
LOG.ensureCompleted(splitp);
for(DBIDIter it = points.getDBIDs().iter(); it.valid(); it.advance()) {
// it might be that a point does not occur for a certain size of a
// projection (likely if do few projections, in this case there is no avg
// distance)
int count = nDists.intValue(it);
double val = (count == 0) ? FastOPTICS.UNDEFINED_DISTANCE : (davg.doubleValue(it) / count);
davg.put(it, val);
}
nDists.destroy(); // No longer needed after normalization
return davg;
} | java |
public boolean containedIn(SparseNumberVector bv) {
int i1 = this.iter(), i2 = bv.iter();
while(this.iterValid(i1)) {
if(!bv.iterValid(i2)) {
return false;
}
int d1 = this.iterDim(i1), d2 = bv.iterDim(i2);
if(d1 < d2) {
return false; // Missing
}
if(d1 == d2) {
if(bv.iterDoubleValue(i2) == 0.) {
return false;
}
i1 = this.iterAdvance(i1);
}
i2 = bv.iterAdvance(i2);
}
return true;
} | java |
public static long[] toBitset(Itemset i, long[] bits) {
for(int it = i.iter(); i.iterValid(it); it = i.iterAdvance(it)) {
BitsUtil.setI(bits, i.iterDim(it));
}
return bits;
} | java |
protected static int compareLexicographical(Itemset a, Itemset o) {
int i1 = a.iter(), i2 = o.iter();
while(a.iterValid(i1) && o.iterValid(i2)) {
int v1 = a.iterDim(i1), v2 = o.iterDim(i2);
if(v1 < v2) {
return -1;
}
if(v2 < v1) {
return +1;
}
i1 = a.iterAdvance(i1);
i2 = o.iterAdvance(i2);
}
return a.iterValid(i1) ? 1 : o.iterValid(i2) ? -1 : 0;
} | java |
public final StringBuilder appendTo(StringBuilder buf, VectorFieldTypeInformation<BitVector> meta) {
appendItemsTo(buf, meta);
return buf.append(": ").append(support);
} | java |
public StringBuilder appendItemsTo(StringBuilder buf, VectorFieldTypeInformation<BitVector> meta) {
int it = this.iter();
if(this.iterValid(it)) {
while(true) {
int v = this.iterDim(it);
String lbl = (meta != null) ? meta.getLabel(v) : null;
if(lbl == null) {
buf.append(v);
}
else {
buf.append(lbl);
}
it = this.iterAdvance(it);
if(!this.iterValid(it)) {
break;
}
buf.append(", ");
}
}
return buf;
} | java |
@Override
public double getWeight(double distance, double max, double stddev) {
if(max <= 0) {
return 1.0;
}
double relativedistance = distance / max;
// -2.303 is log(.1) to suit the intended range of 1.0-0.1
return FastMath.exp(-2.3025850929940455 * relativedistance * relativedistance);
} | java |
@Override
public void writePage(int pageID, P page) {
if (page.isDirty()) {
try {
countWrite();
byte[] array = pageToByteArray(page);
file.getRecordBuffer(pageID).put(array);
page.setDirty(false);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
} | java |
private byte[] pageToByteArray(P page) {
try {
if (page == null) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeInt(EMPTY_PAGE);
oos.close();
baos.close();
byte[] array = baos.toByteArray();
byte[] result = new byte[pageSize];
System.arraycopy(array, 0, result, 0, array.length);
return result;
} else {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeInt(FILLED_PAGE);
oos.writeObject(page);
oos.close();
baos.close();
byte[] array = baos.toByteArray();
if (array.length > this.pageSize) {
throw new IllegalArgumentException("Size of page " + page + " is greater than specified" + " pagesize: " + array.length + " > " + pageSize);
} else if (array.length == this.pageSize) {
return array;
}
else {
byte[] result = new byte[pageSize];
System.arraycopy(array, 0, result, 0, array.length);
return result;
}
}
} catch (IOException e) {
throw new RuntimeException("IOException occurred! ", e);
}
} | java |
public static SinCosTable make(int steps) {
if ((steps & 0x3) == 0) {
return new QuarterTable(steps);
}
if ((steps & 0x1) == 0) {
return new HalfTable(steps);
}
return new FullTable(steps);
} | java |
@Override
protected void process(DBIDRef id, ArrayDBIDs ids, DBIDArrayIter it, int n, WritableDBIDDataStore pi, WritableDoubleDataStore lambda, WritableDoubleDataStore m) {
clinkstep3(id, it, n, pi, lambda, m);
clinkstep4567(id, ids, it, n, pi, lambda, m);
clinkstep8(id, it, n, pi, lambda, m);
} | java |
private void clinkstep8(DBIDRef id, DBIDArrayIter it, int n, WritableDBIDDataStore pi, WritableDoubleDataStore lambda, WritableDoubleDataStore m) {
DBIDVar p_i = DBIDUtil.newVar(), pp_i = DBIDUtil.newVar();
for(it.seek(0); it.getOffset() < n; it.advance()) {
p_i.from(pi, it); // p_i = pi[i]
pp_i.from(pi, p_i); // pp_i = pi[pi[i]]
if(DBIDUtil.equal(pp_i, id) && lambda.doubleValue(it) >= lambda.doubleValue(p_i)) {
pi.putDBID(it, id);
}
}
} | java |
public static int levenshteinDistance(String o1, String o2) {
// Let o1 be the shorter one:
if(o1.length() > o2.length()) {
return levenshteinDistance(o2, o1);
}
final int l1 = o1.length(), l2 = o2.length();
// Exploit that Java caches the hash code of strings:
if(l1 == l2 && o1.hashCode() == o2.hashCode() && o1.equals(o2)) {
return 0;
}
// Determine prefix and postfix lengths:
final int prefix = prefixLen(o1, o2);
if(prefix == l1 || prefix == l2) {
return Math.abs(l1 - l2);
}
final int postfix = postfixLen(o1, o2, prefix);
return // Prefix and postfix are a complete object:
(prefix + postfix == l1 || prefix + postfix == l2) ? Math.abs(l1 - l2) : //
// Exactly one char difference optimization:
(l1 == l2 && prefix + postfix + 1 == l1) ? 1 : //
// Default case, compute
levenshteinDistance(o1, o2, prefix, postfix);
} | java |
private static int prefixLen(String o1, String o2) {
final int l1 = o1.length(), l2 = o2.length(), l = l1 < l2 ? l1 : l2;
int prefix = 0;
while(prefix < l && (o1.charAt(prefix) == o2.charAt(prefix))) {
prefix++;
}
return prefix;
} | java |
private static int postfixLen(String o1, String o2, int prefix) {
int postfix = 0;
int p1 = o1.length(), p2 = o2.length();
while(p1 > prefix && p2 > prefix && (o1.charAt(--p1) == o2.charAt(--p2))) {
++postfix;
}
return postfix;
} | java |
public static int levenshteinDistance(String o1, String o2, int prefix, int postfix) {
final int l1 = o1.length(), l2 = o2.length();
// Buffer, interleaved. Even and odd values are our rows.
int[] buf = new int[(l2 + 1 - (prefix + postfix)) << 1];
// Initial "row", on even positions
for(int j = 0; j < buf.length; j += 2) {
buf[j] = j >> 1;
}
int inter = 1; // Interleaving offset
for(int i = prefix, e1 = l1 - postfix; i < e1; i++, inter ^= 1) {
final char chr = o1.charAt(i);
buf[inter] = i + 1 - prefix; // First entry
for(int c = 2 + inter, p = 3 - inter, j = prefix; c < buf.length; c += 2, p += 2) {
buf[c] = min(buf[p] + 1, buf[c - 2] + 1, buf[p - 2] + ((chr == o2.charAt(j++)) ? 0 : 1));
}
}
return buf[buf.length - 2 + (inter ^ 1)];
} | java |
private static int nextSep(String str, int start) {
int next = str.indexOf(',', start);
return next == -1 ? str.length() : next;
} | java |
public static double[][] computeWeightMatrix(final int quanth, final int quants, final int quantb) {
final int dim = quanth * quants * quantb;
final DoubleWrapper tmp = new DoubleWrapper(); // To return cosine
assert (dim > 0);
final double[][] m = new double[dim][dim];
for(int x = 0; x < dim; x++) {
final int hx = x / (quantb * quants);
final int sx = (x / quantb) % quants;
final int bx = x % quantb;
for(int y = x; y < dim; y++) {
final int hy = y / (quantb * quants);
final int sy = (y / quantb) % quants;
final int by = y % quantb;
final double shx = FastMath.sinAndCos((hx + .5) / quanth * MathUtil.TWOPI, tmp);
final double chx = tmp.value;
final double shy = FastMath.sinAndCos((hy + .5) / quanth * MathUtil.TWOPI, tmp);
final double chy = tmp.value;
final double cos = chx * (sx + .5) / quants - chy * (sy + .5) / quants;
final double sin = shx * (sx + .5) / quants - shy * (sy + .5) / quants;
final double db = (bx - by) / (double) quantb;
final double val = 1. - FastMath.sqrt((db * db + sin * sin + cos * cos) / 5);
m[x][y] = m[y][x] = val;
}
}
return m;
} | java |
public static double[] plus(final double[] v1, final double[] v2) {
assert v1.length == v2.length : ERR_VEC_DIMENSIONS;
final double[] result = new double[v1.length];
for(int i = 0; i < result.length; i++) {
result[i] = v1[i] + v2[i];
}
return result;
} | java |
public static double[] plusEquals(final double[] v1, final double[] v2) {
assert v1.length == v2.length : ERR_VEC_DIMENSIONS;
for(int i = 0; i < v1.length; i++) {
v1[i] += v2[i];
}
return v1;
} | java |
public static double[] plus(final double[] v1, final double s1) {
final double[] result = new double[v1.length];
for(int i = 0; i < result.length; i++) {
result[i] = v1[i] + s1;
}
return result;
} | java |
public static double[] plusEquals(final double[] v1, final double s1) {
for(int i = 0; i < v1.length; i++) {
v1[i] += s1;
}
return v1;
} | java |
public static double[] minus(final double[] v1, final double[] v2) {
assert v1.length == v2.length : ERR_VEC_DIMENSIONS;
final double[] sub = new double[v1.length];
for(int i = 0; i < v1.length; i++) {
sub[i] = v1[i] - v2[i];
}
return sub;
} | java |
public static double[] minusEquals(final double[] v1, final double[] v2) {
assert v1.length == v2.length : ERR_VEC_DIMENSIONS;
for(int i = 0; i < v1.length; i++) {
v1[i] -= v2[i];
}
return v1;
} | java |
public static double[] minus(final double[] v1, final double s1) {
final double[] result = new double[v1.length];
for(int i = 0; i < v1.length; i++) {
result[i] = v1[i] - s1;
}
return result;
} | java |
public static double[] minusEquals(final double[] v1, final double s1) {
for(int i = 0; i < v1.length; i++) {
v1[i] -= s1;
}
return v1;
} | java |
public static double sum(final double[] v1) {
double acc = 0.;
for(int row = 0; row < v1.length; row++) {
acc += v1[row];
}
return acc;
} | java |
public static int argmax(double[] v) {
assert (v.length > 0);
int maxIndex = 0;
double currentMax = v[0];
for(int i = 1; i < v.length; i++) {
final double x = v[i];
if(x > currentMax) {
maxIndex = i;
currentMax = x;
}
}
return maxIndex;
} | java |
public static double[] normalize(final double[] v1) {
final double norm = 1. / euclideanLength(v1);
double[] re = new double[v1.length];
if(norm < Double.POSITIVE_INFINITY) {
for(int row = 0; row < v1.length; row++) {
re[row] = v1[row] * norm;
}
}
return re;
} | java |
public static double[] normalizeEquals(final double[] v1) {
final double norm = 1. / euclideanLength(v1);
if(norm < Double.POSITIVE_INFINITY) {
for(int row = 0; row < v1.length; row++) {
v1[row] *= norm;
}
}
return v1;
} | java |
public static void clear(final double[][] m) {
for(int i = 0; i < m.length; i++) {
Arrays.fill(m[i], 0.0);
}
} | java |
public static double[] rotate90Equals(final double[] v1) {
assert v1.length == 2 : "rotate90Equals is only valid for 2d vectors.";
final double temp = v1[0];
v1[0] = v1[1];
v1[1] = -temp;
return v1;
} | java |
public static double[][] diagonal(final double[] v1) {
final int dim = v1.length;
final double[][] result = new double[dim][dim];
for(int i = 0; i < dim; i++) {
result[i][i] = v1[i];
}
return result;
} | java |
public static double[][] copy(final double[][] m1) {
final int rowdim = m1.length, coldim = getColumnDimensionality(m1);
final double[][] X = new double[rowdim][coldim];
for(int i = 0; i < rowdim; i++) {
System.arraycopy(m1[i], 0, X[i], 0, coldim);
}
return X;
} | java |
public static double[] getCol(double[][] m1, int col) {
double[] ret = new double[m1.length];
for(int i = 0; i < ret.length; i++) {
ret[i] = m1[i][col];
}
return ret;
} | java |
public static double[] getDiagonal(final double[][] m1) {
final int dim = Math.min(getColumnDimensionality(m1), m1.length);
final double[] diagonal = new double[dim];
for(int i = 0; i < dim; i++) {
diagonal[i] = m1[i][i];
}
return diagonal;
} | java |
public static void normalizeColumns(final double[][] m1) {
final int columndimension = getColumnDimensionality(m1);
for(int col = 0; col < columndimension; col++) {
double norm = 0.0;
for(int row = 0; row < m1.length; row++) {
final double v = m1[row][col];
norm += v * v;
}
if(norm > 0) {
norm = FastMath.sqrt(norm);
for(int row = 0; row < m1.length; row++) {
m1[row][col] /= norm;
}
}
}
} | java |
public static double[][] appendColumns(final double[][] m1, final double[][] m2) {
final int columndimension = getColumnDimensionality(m1);
final int ccolumndimension = getColumnDimensionality(m2);
assert m1.length == m2.length : "m.getRowDimension() != column.getRowDimension()";
final int rcolumndimension = columndimension + ccolumndimension;
final double[][] result = new double[m1.length][rcolumndimension];
for(int i = 0; i < rcolumndimension; i++) {
// FIXME: optimize - excess copying!
if(i < columndimension) {
setCol(result, i, getCol(m1, i));
}
else {
setCol(result, i, getCol(m2, i - columndimension));
}
}
return result;
} | java |
public static double[][] orthonormalize(final double[][] m1) {
final int columndimension = getColumnDimensionality(m1);
final double[][] v = copy(m1);
// FIXME: optimize - excess copying!
for(int i = 1; i < columndimension; i++) {
final double[] u_i = getCol(m1, i);
final double[] sum = new double[m1.length];
for(int j = 0; j < i; j++) {
final double[] v_j = getCol(v, j);
final double scalar = scalarProduct(u_i, v_j) / scalarProduct(v_j, v_j);
plusEquals(sum, times(v_j, scalar));
}
final double[] v_i = minus(u_i, sum);
setCol(v, i, v_i);
}
normalizeColumns(v);
return v;
} | java |
public static double[][] inverse(double[][] A) {
final int rows = A.length, cols = A[0].length;
return rows == cols //
? (new LUDecomposition(A, rows, cols)).inverse() //
: (new QRDecomposition(A, rows, cols)).inverse();
} | java |
public static boolean almostEquals(final double[] m1, final double[] m2, final double maxdelta) {
if(m1 == m2) {
return true;
}
if(m1 == null || m2 == null) {
return false;
}
final int rowdim = m1.length;
if(rowdim != m2.length) {
return false;
}
for(int i = 0; i < rowdim; i++) {
if(Math.abs(m1[i] - m2[i]) > maxdelta) {
return false;
}
}
return true;
} | java |
public static double angle(double[] v1, double[] v2) {
final int mindim = (v1.length <= v2.length) ? v1.length : v2.length;
// Essentially, we want to compute this:
// v1.transposeTimes(v2) / (v1.euclideanLength() * v2.euclideanLength());
// We can just compute all three in parallel.
double s = 0, e1 = 0, e2 = 0;
for(int k = 0; k < mindim; k++) {
final double r1 = v1[k], r2 = v2[k];
s += r1 * r2;
e1 += r1 * r1;
e2 += r2 * r2;
}
for(int k = mindim; k < v1.length; k++) {
final double r1 = v1[k];
e1 += r1 * r1;
}
for(int k = mindim; k < v2.length; k++) {
final double r2 = v2[k];
e2 += r2 * r2;
}
double a = FastMath.sqrt((s / e1) * (s / e2));
return (a < 1.) ? a : 1.;
} | java |
protected void updateFromSelection() {
DBIDSelection sel = context.getSelection();
if(sel != null) {
this.dbids = DBIDUtil.newArray(sel.getSelectedIds());
this.dbids.sort();
}
else {
this.dbids = DBIDUtil.newArray();
}
} | java |
public static DataStoreEvent insertionEvent(DBIDs inserts) {
return new DataStoreEvent(inserts, DBIDUtil.EMPTYDBIDS, DBIDUtil.EMPTYDBIDS);
} | java |
public static DataStoreEvent removalEvent(DBIDs removals) {
return new DataStoreEvent(DBIDUtil.EMPTYDBIDS, removals, DBIDUtil.EMPTYDBIDS);
} | java |
public static DataStoreEvent updateEvent(DBIDs updates) {
return new DataStoreEvent(DBIDUtil.EMPTYDBIDS, DBIDUtil.EMPTYDBIDS, updates);
} | java |
private Visualization instantiateVisualization(VisualizationTask task) {
try {
Visualization v = task.getFactory().makeVisualization(context, task, this, width, height, item.proj);
if(task.has(RenderFlag.NO_EXPORT)) {
v.getLayer().setAttribute(NO_EXPORT_ATTRIBUTE, NO_EXPORT_ATTRIBUTE);
}
return v;
}
catch(Exception e) {
if(LOG.isDebugging()) {
LOG.warning("Visualizer " + task.getFactory().getClass().getName() + " failed.", e);
}
else {
LOG.warning("Visualizer " + task.getFactory().getClass().getName() + " failed - enable debugging to see details: " + e.toString());
}
}
return null;
} | java |
public void destroy() {
context.removeVisualizationListener(this);
context.removeResultListener(this);
for(Entry<VisualizationTask, Visualization> v : taskmap.entrySet()) {
Visualization vis = v.getValue();
if(vis != null) {
vis.destroy();
}
}
taskmap.clear();
} | java |
private void lazyRefresh() {
Runnable pr = new Runnable() {
@Override
public void run() {
if(pendingRefresh.compareAndSet(this, null)) {
refresh();
}
}
};
pendingRefresh.set(pr);
scheduleUpdate(pr);
} | java |
public boolean nextLine() throws IOException {
while(reader.readLine(buf.delete(0, buf.length()))) {
++lineNumber;
if(lengthWithoutLinefeed(buf) > 0) {
return true;
}
}
return false;
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.