Example 1 with Swapper
use of cern.colt.Swapper in project jAudioGIT by dmcennis.
the class Partitioning method partition.
/**
*Same as {@link cern.colt.Partitioning#partition(int[],int,int,int[],int,int,int[])}
*except that it <i>synchronously</i> partitions the rows of the given matrix by the values of the given matrix column;
*This is essentially the same as partitioning a list of composite objects by some instance variable;
*In other words, two entire rows of the matrix are swapped, whenever two column values indicate so.
*<p>
*Let's say, a "row" is an "object" (tuple, d-dimensional point).
*A "column" is the list of "object" values of a given variable (field, dimension).
*A "matrix" is a list of "objects" (tuples, points).
*<p>
*Now, rows (objects, tuples) are partially sorted according to their values in one given variable (dimension).
*Two entire rows of the matrix are swapped, whenever two column values indicate so.
*<p>
*Note that arguments are not checked for validity.
*<p>
*<b>Example:</b>
*<table border="1" cellspacing="0">
* <tr nowrap>
* <td valign="top"><tt>8 x 3 matrix:<br>
* 23, 22, 21<br>
* 20, 19, 18<br>
* 17, 16, 15<br>
* 14, 13, 12<br>
* 11, 10, 9<br>
* 8, 7, 6<br>
* 5, 4, 3<br>
* 2, 1, 0 </tt></td>
* <td align="left" valign="top">
* <p><tt>column = 0;<br>
* rowIndexes = {0,1,2,..,matrix.rows()-1};
* rowFrom = 0;<br>
* rowTo = matrix.rows()-1;<br>
* splitters = {5,10,12}<br>
* c = 0; <br>
* d = splitters.length-1;<br>
* partition(matrix,rowIndexes,rowFrom,rowTo,column,splitters,c,d,splitIndexes);<br>
* ==><br>
* splitIndexes == {0, 2, 3}<br>
* rowIndexes == {7, 6, 5, 4, 0, 1, 2, 3}</tt></p>
* </td>
* <td valign="top">
* The matrix IS NOT REORDERED.<br>
* Here is how it would look<br>
* like, if it would be reordered<br>
* accoring to <tt>rowIndexes</tt>.<br>
* <tt>8 x 3 matrix:<br>
* 2, 1, 0<br>
* 5, 4, 3<br>
* 8, 7, 6<br>
* 11, 10, 9<br>
* 23, 22, 21<br>
* 20, 19, 18<br>
* 17, 16, 15<br>
* 14, 13, 12 </tt></td>
* </tr>
*</table>
*@param matrix the matrix to be partitioned.
*@param rowIndexes the index of the i-th row; is modified by this method to reflect partitioned indexes.
*@param rowFrom the index of the first row (inclusive).
*@param rowTo the index of the last row (inclusive).
*@param column the index of the column to partition on.
*@param splitters the values at which the rows shall be split into intervals.
* Must be sorted ascending and must not contain multiple identical values.
* These preconditions are not checked; be sure that they are met.
*
*@param splitFrom the index of the first splitter element to be considered.
*@param splitTo the index of the last splitter element to be considered.
* The method considers the splitter elements <tt>splitters[splitFrom] .. splitters[splitTo]</tt>.
*
*@param splitIndexes a list into which this method fills the indexes of rows delimiting intervals.
*Upon return <tt>splitIndexes[splitFrom..splitTo]</tt> will be set accordingly.
*Therefore, must satisfy <tt>splitIndexes.length >= splitters.length</tt>.
*/
public static void partition(ObjectMatrix2D matrix, int[] rowIndexes, int rowFrom, int rowTo, int column, final Object[] splitters, int splitFrom, int splitTo, int[] splitIndexes) {
if (rowFrom < 0 || rowTo >= matrix.rows() || rowTo >= rowIndexes.length)
throw new IllegalArgumentException();
if (column < 0 || column >= matrix.columns())
throw new IllegalArgumentException();
if (splitFrom < 0 || splitTo >= splitters.length)
throw new IllegalArgumentException();
if (splitIndexes.length < splitters.length)
throw new IllegalArgumentException();
// this one knows how to swap two row indexes (a,b)
final int[] g = rowIndexes;
Swapper swapper = new Swapper() {
public void swap(int b, int c) {
int tmp = g[b];
g[b] = g[c];
g[c] = tmp;
}
};
// compare splitter[a] with columnView[rowIndexes[b]]
final ObjectMatrix1D columnView = matrix.viewColumn(column);
IntComparator comp = new IntComparator() {
public int compare(int a, int b) {
Comparable av = (Comparable) (splitters[a]);
Comparable bv = (Comparable) (columnView.getQuick(g[b]));
int r = av.compareTo(bv);
return r < 0 ? -1 : (r == 0 ? 0 : 1);
}
};
// compare columnView[rowIndexes[a]] with columnView[rowIndexes[b]]
IntComparator comp2 = new IntComparator() {
public int compare(int a, int b) {
Comparable av = (Comparable) (columnView.getQuick(g[a]));
Comparable bv = (Comparable) (columnView.getQuick(g[b]));
int r = av.compareTo(bv);
return r < 0 ? -1 : (r == 0 ? 0 : 1);
}
};
// compare splitter[a] with splitter[b]
IntComparator comp3 = new IntComparator() {
public int compare(int a, int b) {
Comparable av = (Comparable) (splitters[a]);
Comparable bv = (Comparable) (splitters[b]);
int r = av.compareTo(bv);
return r < 0 ? -1 : (r == 0 ? 0 : 1);
}
};
// generic partitioning does the main work of reordering row indexes
cern.colt.Partitioning.genericPartition(rowFrom, rowTo, splitFrom, splitTo, splitIndexes, comp, comp2, comp3, swapper);
}
Also used :
IntComparator(cern.colt.function.IntComparator)
Swapper(cern.colt.Swapper)
ObjectMatrix1D(cern.colt.matrix.ObjectMatrix1D)
Example 2 with Swapper
use of cern.colt.Swapper in project jAudioGIT by dmcennis.
the class Partitioning method partition.
/**
*Same as {@link cern.colt.Partitioning#partition(int[],int,int,int[],int,int,int[])}
*except that it <i>synchronously</i> partitions the rows of the given matrix by the values of the given matrix column;
*This is essentially the same as partitioning a list of composite objects by some instance variable;
*In other words, two entire rows of the matrix are swapped, whenever two column values indicate so.
*<p>
*Let's say, a "row" is an "object" (tuple, d-dimensional point).
*A "column" is the list of "object" values of a given variable (field, dimension).
*A "matrix" is a list of "objects" (tuples, points).
*<p>
*Now, rows (objects, tuples) are partially sorted according to their values in one given variable (dimension).
*Two entire rows of the matrix are swapped, whenever two column values indicate so.
*<p>
*Note that arguments are not checked for validity.
*<p>
*<b>Example:</b>
*<table border="1" cellspacing="0">
* <tr nowrap>
* <td valign="top"><tt>8 x 3 matrix:<br>
* 23, 22, 21<br>
* 20, 19, 18<br>
* 17, 16, 15<br>
* 14, 13, 12<br>
* 11, 10, 9<br>
* 8, 7, 6<br>
* 5, 4, 3<br>
* 2, 1, 0 </tt></td>
* <td align="left" valign="top">
* <p><tt>column = 0;<br>
* rowIndexes = {0,1,2,..,matrix.rows()-1};
* rowFrom = 0;<br>
* rowTo = matrix.rows()-1;<br>
* splitters = {5,10,12}<br>
* c = 0; <br>
* d = splitters.length-1;<br>
* partition(matrix,rowIndexes,rowFrom,rowTo,column,splitters,c,d,splitIndexes);<br>
* ==><br>
* splitIndexes == {0, 2, 3}<br>
* rowIndexes == {7, 6, 5, 4, 0, 1, 2, 3}</tt></p>
* </td>
* <td valign="top">
* The matrix IS NOT REORDERED.<br>
* Here is how it would look<br>
* like, if it would be reordered<br>
* accoring to <tt>rowIndexes</tt>.<br>
* <tt>8 x 3 matrix:<br>
* 2, 1, 0<br>
* 5, 4, 3<br>
* 8, 7, 6<br>
* 11, 10, 9<br>
* 23, 22, 21<br>
* 20, 19, 18<br>
* 17, 16, 15<br>
* 14, 13, 12 </tt></td>
* </tr>
*</table>
*@param matrix the matrix to be partitioned.
*@param rowIndexes the index of the i-th row; is modified by this method to reflect partitioned indexes.
*@param rowFrom the index of the first row (inclusive).
*@param rowTo the index of the last row (inclusive).
*@param column the index of the column to partition on.
*@param splitters the values at which the rows shall be split into intervals.
* Must be sorted ascending and must not contain multiple identical values.
* These preconditions are not checked; be sure that they are met.
*
*@param splitFrom the index of the first splitter element to be considered.
*@param splitTo the index of the last splitter element to be considered.
* The method considers the splitter elements <tt>splitters[splitFrom] .. splitters[splitTo]</tt>.
*
*@param splitIndexes a list into which this method fills the indexes of rows delimiting intervals.
*Upon return <tt>splitIndexes[splitFrom..splitTo]</tt> will be set accordingly.
*Therefore, must satisfy <tt>splitIndexes.length >= splitters.length</tt>.
*/
public static void partition(DoubleMatrix2D matrix, int[] rowIndexes, int rowFrom, int rowTo, int column, final double[] splitters, int splitFrom, int splitTo, int[] splitIndexes) {
if (rowFrom < 0 || rowTo >= matrix.rows() || rowTo >= rowIndexes.length)
throw new IllegalArgumentException();
if (column < 0 || column >= matrix.columns())
throw new IllegalArgumentException();
if (splitFrom < 0 || splitTo >= splitters.length)
throw new IllegalArgumentException();
if (splitIndexes.length < splitters.length)
throw new IllegalArgumentException();
// this one knows how to swap two row indexes (a,b)
final int[] g = rowIndexes;
Swapper swapper = new Swapper() {
public void swap(int b, int c) {
int tmp = g[b];
g[b] = g[c];
g[c] = tmp;
}
};
// compare splitter[a] with columnView[rowIndexes[b]]
final DoubleMatrix1D columnView = matrix.viewColumn(column);
IntComparator comp = new IntComparator() {
public int compare(int a, int b) {
double av = splitters[a];
double bv = columnView.getQuick(g[b]);
return av < bv ? -1 : (av == bv ? 0 : 1);
}
};
// compare columnView[rowIndexes[a]] with columnView[rowIndexes[b]]
IntComparator comp2 = new IntComparator() {
public int compare(int a, int b) {
double av = columnView.getQuick(g[a]);
double bv = columnView.getQuick(g[b]);
return av < bv ? -1 : (av == bv ? 0 : 1);
}
};
// compare splitter[a] with splitter[b]
IntComparator comp3 = new IntComparator() {
public int compare(int a, int b) {
double av = splitters[a];
double bv = splitters[b];
return av < bv ? -1 : (av == bv ? 0 : 1);
}
};
// generic partitioning does the main work of reordering row indexes
cern.colt.Partitioning.genericPartition(rowFrom, rowTo, splitFrom, splitTo, splitIndexes, comp, comp2, comp3, swapper);
}
Also used :
DoubleMatrix1D(cern.colt.matrix.DoubleMatrix1D)
IntComparator(cern.colt.function.IntComparator)
Swapper(cern.colt.Swapper)
Example 3 with Swapper
use of cern.colt.Swapper in project tdq-studio-se by Talend.
the class Partitioning method partition.
/**
*Same as {@link cern.colt.Partitioning#partition(int[],int,int,int[],int,int,int[])}
*except that it <i>synchronously</i> partitions the rows of the given matrix by the values of the given matrix column;
*This is essentially the same as partitioning a list of composite objects by some instance variable;
*In other words, two entire rows of the matrix are swapped, whenever two column values indicate so.
*<p>
*Let's say, a "row" is an "object" (tuple, d-dimensional point).
*A "column" is the list of "object" values of a given variable (field, dimension).
*A "matrix" is a list of "objects" (tuples, points).
*<p>
*Now, rows (objects, tuples) are partially sorted according to their values in one given variable (dimension).
*Two entire rows of the matrix are swapped, whenever two column values indicate so.
*<p>
*Note that arguments are not checked for validity.
*<p>
*<b>Example:</b>
*<table border="1" cellspacing="0">
* <tr nowrap>
* <td valign="top"><tt>8 x 3 matrix:<br>
* 23, 22, 21<br>
* 20, 19, 18<br>
* 17, 16, 15<br>
* 14, 13, 12<br>
* 11, 10, 9<br>
* 8, 7, 6<br>
* 5, 4, 3<br>
* 2, 1, 0 </tt></td>
* <td align="left" valign="top">
* <p><tt>column = 0;<br>
* rowIndexes = {0,1,2,..,matrix.rows()-1};
* rowFrom = 0;<br>
* rowTo = matrix.rows()-1;<br>
* splitters = {5,10,12}<br>
* c = 0; <br>
* d = splitters.length-1;<br>
* partition(matrix,rowIndexes,rowFrom,rowTo,column,splitters,c,d,splitIndexes);<br>
* ==><br>
* splitIndexes == {0, 2, 3}<br>
* rowIndexes == {7, 6, 5, 4, 0, 1, 2, 3}</tt></p>
* </td>
* <td valign="top">
* The matrix IS NOT REORDERED.<br>
* Here is how it would look<br>
* like, if it would be reordered<br>
* accoring to <tt>rowIndexes</tt>.<br>
* <tt>8 x 3 matrix:<br>
* 2, 1, 0<br>
* 5, 4, 3<br>
* 8, 7, 6<br>
* 11, 10, 9<br>
* 23, 22, 21<br>
* 20, 19, 18<br>
* 17, 16, 15<br>
* 14, 13, 12 </tt></td>
* </tr>
*</table>
*@param matrix the matrix to be partitioned.
*@param rowIndexes the index of the i-th row; is modified by this method to reflect partitioned indexes.
*@param rowFrom the index of the first row (inclusive).
*@param rowTo the index of the last row (inclusive).
*@param column the index of the column to partition on.
*@param splitters the values at which the rows shall be split into intervals.
* Must be sorted ascending and must not contain multiple identical values.
* These preconditions are not checked; be sure that they are met.
*
*@param splitFrom the index of the first splitter element to be considered.
*@param splitTo the index of the last splitter element to be considered.
* The method considers the splitter elements <tt>splitters[splitFrom] .. splitters[splitTo]</tt>.
*
*@param splitIndexes a list into which this method fills the indexes of rows delimiting intervals.
*Upon return <tt>splitIndexes[splitFrom..splitTo]</tt> will be set accordingly.
*Therefore, must satisfy <tt>splitIndexes.length >= splitters.length</tt>.
*/
public static void partition(DoubleMatrix2D matrix, int[] rowIndexes, int rowFrom, int rowTo, int column, final double[] splitters, int splitFrom, int splitTo, int[] splitIndexes) {
if (rowFrom < 0 || rowTo >= matrix.rows() || rowTo >= rowIndexes.length)
throw new IllegalArgumentException();
if (column < 0 || column >= matrix.columns())
throw new IllegalArgumentException();
if (splitFrom < 0 || splitTo >= splitters.length)
throw new IllegalArgumentException();
if (splitIndexes.length < splitters.length)
throw new IllegalArgumentException();
// this one knows how to swap two row indexes (a,b)
final int[] g = rowIndexes;
Swapper swapper = new Swapper() {
public void swap(int b, int c) {
int tmp = g[b];
g[b] = g[c];
g[c] = tmp;
}
};
// compare splitter[a] with columnView[rowIndexes[b]]
final DoubleMatrix1D columnView = matrix.viewColumn(column);
IntComparator comp = new IntComparator() {
public int compare(int a, int b) {
double av = splitters[a];
double bv = columnView.getQuick(g[b]);
return av < bv ? -1 : (av == bv ? 0 : 1);
}
};
// compare columnView[rowIndexes[a]] with columnView[rowIndexes[b]]
IntComparator comp2 = new IntComparator() {
public int compare(int a, int b) {
double av = columnView.getQuick(g[a]);
double bv = columnView.getQuick(g[b]);
return av < bv ? -1 : (av == bv ? 0 : 1);
}
};
// compare splitter[a] with splitter[b]
IntComparator comp3 = new IntComparator() {
public int compare(int a, int b) {
double av = splitters[a];
double bv = splitters[b];
return av < bv ? -1 : (av == bv ? 0 : 1);
}
};
// generic partitioning does the main work of reordering row indexes
cern.colt.Partitioning.genericPartition(rowFrom, rowTo, splitFrom, splitTo, splitIndexes, comp, comp2, comp3, swapper);
}
Also used :
DoubleMatrix1D(cern.colt.matrix.DoubleMatrix1D)
IntComparator(cern.colt.function.IntComparator)
Swapper(cern.colt.Swapper)
Example 4 with Swapper
use of cern.colt.Swapper in project tdq-studio-se by Talend.
the class Partitioning method partition.
/**
*Same as {@link cern.colt.Partitioning#partition(int[],int,int,int[],int,int,int[])}
*except that it <i>synchronously</i> partitions the rows of the given matrix by the values of the given matrix column;
*This is essentially the same as partitioning a list of composite objects by some instance variable;
*In other words, two entire rows of the matrix are swapped, whenever two column values indicate so.
*<p>
*Let's say, a "row" is an "object" (tuple, d-dimensional point).
*A "column" is the list of "object" values of a given variable (field, dimension).
*A "matrix" is a list of "objects" (tuples, points).
*<p>
*Now, rows (objects, tuples) are partially sorted according to their values in one given variable (dimension).
*Two entire rows of the matrix are swapped, whenever two column values indicate so.
*<p>
*Note that arguments are not checked for validity.
*<p>
*<b>Example:</b>
*<table border="1" cellspacing="0">
* <tr nowrap>
* <td valign="top"><tt>8 x 3 matrix:<br>
* 23, 22, 21<br>
* 20, 19, 18<br>
* 17, 16, 15<br>
* 14, 13, 12<br>
* 11, 10, 9<br>
* 8, 7, 6<br>
* 5, 4, 3<br>
* 2, 1, 0 </tt></td>
* <td align="left" valign="top">
* <p><tt>column = 0;<br>
* rowIndexes = {0,1,2,..,matrix.rows()-1};
* rowFrom = 0;<br>
* rowTo = matrix.rows()-1;<br>
* splitters = {5,10,12}<br>
* c = 0; <br>
* d = splitters.length-1;<br>
* partition(matrix,rowIndexes,rowFrom,rowTo,column,splitters,c,d,splitIndexes);<br>
* ==><br>
* splitIndexes == {0, 2, 3}<br>
* rowIndexes == {7, 6, 5, 4, 0, 1, 2, 3}</tt></p>
* </td>
* <td valign="top">
* The matrix IS NOT REORDERED.<br>
* Here is how it would look<br>
* like, if it would be reordered<br>
* accoring to <tt>rowIndexes</tt>.<br>
* <tt>8 x 3 matrix:<br>
* 2, 1, 0<br>
* 5, 4, 3<br>
* 8, 7, 6<br>
* 11, 10, 9<br>
* 23, 22, 21<br>
* 20, 19, 18<br>
* 17, 16, 15<br>
* 14, 13, 12 </tt></td>
* </tr>
*</table>
*@param matrix the matrix to be partitioned.
*@param rowIndexes the index of the i-th row; is modified by this method to reflect partitioned indexes.
*@param rowFrom the index of the first row (inclusive).
*@param rowTo the index of the last row (inclusive).
*@param column the index of the column to partition on.
*@param splitters the values at which the rows shall be split into intervals.
* Must be sorted ascending and must not contain multiple identical values.
* These preconditions are not checked; be sure that they are met.
*
*@param splitFrom the index of the first splitter element to be considered.
*@param splitTo the index of the last splitter element to be considered.
* The method considers the splitter elements <tt>splitters[splitFrom] .. splitters[splitTo]</tt>.
*
*@param splitIndexes a list into which this method fills the indexes of rows delimiting intervals.
*Upon return <tt>splitIndexes[splitFrom..splitTo]</tt> will be set accordingly.
*Therefore, must satisfy <tt>splitIndexes.length >= splitters.length</tt>.
*/
public static void partition(ObjectMatrix2D matrix, int[] rowIndexes, int rowFrom, int rowTo, int column, final Object[] splitters, int splitFrom, int splitTo, int[] splitIndexes) {
if (rowFrom < 0 || rowTo >= matrix.rows() || rowTo >= rowIndexes.length)
throw new IllegalArgumentException();
if (column < 0 || column >= matrix.columns())
throw new IllegalArgumentException();
if (splitFrom < 0 || splitTo >= splitters.length)
throw new IllegalArgumentException();
if (splitIndexes.length < splitters.length)
throw new IllegalArgumentException();
// this one knows how to swap two row indexes (a,b)
final int[] g = rowIndexes;
Swapper swapper = new Swapper() {
public void swap(int b, int c) {
int tmp = g[b];
g[b] = g[c];
g[c] = tmp;
}
};
// compare splitter[a] with columnView[rowIndexes[b]]
final ObjectMatrix1D columnView = matrix.viewColumn(column);
IntComparator comp = new IntComparator() {
public int compare(int a, int b) {
Comparable av = (Comparable) (splitters[a]);
Comparable bv = (Comparable) (columnView.getQuick(g[b]));
int r = av.compareTo(bv);
return r < 0 ? -1 : (r == 0 ? 0 : 1);
}
};
// compare columnView[rowIndexes[a]] with columnView[rowIndexes[b]]
IntComparator comp2 = new IntComparator() {
public int compare(int a, int b) {
Comparable av = (Comparable) (columnView.getQuick(g[a]));
Comparable bv = (Comparable) (columnView.getQuick(g[b]));
int r = av.compareTo(bv);
return r < 0 ? -1 : (r == 0 ? 0 : 1);
}
};
// compare splitter[a] with splitter[b]
IntComparator comp3 = new IntComparator() {
public int compare(int a, int b) {
Comparable av = (Comparable) (splitters[a]);
Comparable bv = (Comparable) (splitters[b]);
int r = av.compareTo(bv);
return r < 0 ? -1 : (r == 0 ? 0 : 1);
}
};
// generic partitioning does the main work of reordering row indexes
cern.colt.Partitioning.genericPartition(rowFrom, rowTo, splitFrom, splitTo, splitIndexes, comp, comp2, comp3, swapper);
}
Also used :
IntComparator(cern.colt.function.IntComparator)
Swapper(cern.colt.Swapper)
ObjectMatrix1D(cern.colt.matrix.ObjectMatrix1D)
Aggregations
Swapper (cern.colt.Swapper)4
IntComparator (cern.colt.function.IntComparator)4
DoubleMatrix1D (cern.colt.matrix.DoubleMatrix1D)2
ObjectMatrix1D (cern.colt.matrix.ObjectMatrix1D)2
