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.fastPro... | 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()) {
// ch... | 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(en... | 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.co... | 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> pcl... | 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.l... | 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) - ... | 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] ==... | 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());
}
... | 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];
dou... | 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... | 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... | 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.rand... | 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()) {
parame... | 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()... | 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... | 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(co... | 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.ser... | 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 M... | 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;
f... | 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)) {
... | 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 + E... | 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.fastProjectDataToRende... | 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 computati... | 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 = ... | 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(... | 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, ... | 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);
Fini... | 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) ... | 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.iterAdvan... | 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... | 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.toByteArr... | 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.fro... | 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()... | 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... | 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++) ... | 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;
}
... | 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 rcolumndimen... | 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... | 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 < rowd... | 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, e... | 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);
}
... | 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.