cern.colt.matrix.tfloat.algo.FloatFormatter Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of parallelcolt Show documentation
Show all versions of parallelcolt Show documentation
Parallel Colt is a multithreaded version of Colt - a library for high performance scientific computing in Java. It contains efficient algorithms for data analysis, linear algebra, multi-dimensional arrays, Fourier transforms, statistics and histogramming.
The newest version!
/*
Copyright (C) 1999 CERN - European Organization for Nuclear Research.
Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose
is hereby granted without fee, provided that the above copyright notice appear in all copies and
that both that copyright notice and this permission notice appear in supporting documentation.
CERN makes no representations about the suitability of this software for any purpose.
It is provided "as is" without expressed or implied warranty.
*/
package cern.colt.matrix.tfloat.algo;
import cern.colt.matrix.AbstractFormatter;
import cern.colt.matrix.AbstractMatrix1D;
import cern.colt.matrix.AbstractMatrix2D;
import cern.colt.matrix.Former;
import cern.colt.matrix.tfloat.FloatMatrix1D;
import cern.colt.matrix.tfloat.FloatMatrix2D;
import cern.colt.matrix.tfloat.FloatMatrix3D;
import cern.colt.matrix.tfloat.impl.DenseFloatMatrix1D;
/**
* Flexible, well human readable matrix print formatting; By default decimal
* point aligned. Currenly works on 1-d, 2-d and 3-d matrices. Note that in most
* cases you will not need to get familiar with this class; just call
* matrix.toString() and be happy with the default formatting. This
* class is for advanced requirements.
*
* Examples:
*
* Examples demonstrate usage on 2-d matrices. 1-d and 3-d matrices formatting
* works very similar.
*
*
* Original matrix
*
*
*
*
*
* float[][] values = {
{3, 0, -3.4, 0},
{5.1 ,0, +3.0123456789, 0},
{16.37, 0.0, 2.5, 0},
{-16.3, 0, -3.012345678E-4, -1},
{1236.3456789, 0, 7, -1.2}
};
matrix = new DenseFloatMatrix2D(values);
*
*
*
*
*
*
*
*
*
* format
* Formatter.toString(matrix);
* Formatter.toSourceCode(matrix);
*
*
* %G
* (default)
* 5 x 4 matrix
3 0 -3.4 0
5.1 0 3.012346 0
16.37 0 2.5 0
-16.3 0 -0.000301 -1
1236.345679 0 7 -1.2
* {
{ 3 , 0, -3.4 , 0 },
{ 5.1 , 0, 3.012346, 0 },
{ 16.37 , 0, 2.5 , 0 },
{ -16.3 , 0, -0.000301, -1 },
{1236.345679, 0, 7 , -1.2}
};
*
*
* %1.10G
* 5 x 4 matrix
3 0 -3.4 0
5.1 0 3.0123456789 0
16.37 0 2.5 0
-16.3 0 -0.0003012346 -1
1236.3456789 0 7 -1.2
* {
{ 3 , 0, -3.4 , 0 },
{ 5.1 , 0, 3.0123456789, 0 },
{ 16.37 , 0, 2.5 , 0 },
{ -16.3 , 0, -0.0003012346, -1 },
{1236.3456789, 0, 7 , -1.2}
};
*
*
* %f
* 5 x 4 matrix
3.000000 0.000000 -3.400000 0.000000
5.100000 0.000000 3.012346 0.000000
16.370000 0.000000 2.500000 0.000000
-16.300000 0.000000 -0.000301 -1.000000
1236.345679 0.000000 7.000000 -1.200000
* {
{ 3.000000, 0.000000, -3.400000, 0.000000},
{ 5.100000, 0.000000, 3.012346, 0.000000},
{ 16.370000, 0.000000, 2.500000, 0.000000},
{ -16.300000, 0.000000, -0.000301, -1.000000},
{1236.345679, 0.000000, 7.000000, -1.200000}
};
*
*
* %1.2f
* 5 x 4 matrix
3.00 0.00 -3.40 0.00
5.10 0.00 3.01 0.00
16.37 0.00 2.50 0.00
-16.30 0.00 -0.00 -1.00
1236.35 0.00 7.00 -1.20
* {
{ 3.00, 0.00, -3.40, 0.00},
{ 5.10, 0.00, 3.01, 0.00},
{ 16.37, 0.00, 2.50, 0.00},
{ -16.30, 0.00, -0.00, -1.00},
{1236.35, 0.00, 7.00, -1.20}
};
*
*
* %0.2e
* 5 x 4 matrix
3.00e+000 0.00e+000 -3.40e+000 0.00e+000
5.10e+000 0.00e+000 3.01e+000 0.00e+000
1.64e+001 0.00e+000 2.50e+000 0.00e+000
-1.63e+001 0.00e+000 -3.01e-004 -1.00e+000
1.24e+003 0.00e+000 7.00e+000 -1.20e+000
* {
{ 3.00e+000, 0.00e+000, -3.40e+000, 0.00e+000},
{ 5.10e+000, 0.00e+000, 3.01e+000, 0.00e+000},
{ 1.64e+001, 0.00e+000, 2.50e+000, 0.00e+000},
{-1.63e+001, 0.00e+000, -3.01e-004, -1.00e+000},
{ 1.24e+003, 0.00e+000, 7.00e+000, -1.20e+000}
};
*
*
* null
* 5 x 4 matrix
3.0 0.0 -3.4 0.0
5.1 0.0 3.0123456789 0.0
16.37 0.0 2.5 0.0
-16.3 0.0 -3.012345678E-4 -1.0
1236.3456789 0.0 7.0 -1.2
* {
{ 3.0 , 0.0, -3.4 , 0.0},
{ 5.1 , 0.0, 3.0123456789 , 0.0},
{ 16.37 , 0.0, 2.5 , 0.0},
{ -16.3 , 0.0, -3.012345678E-4, -1.0},
{1236.3456789, 0.0, 7.0 , -1.2}
};
*
*
*
*
* Here are some more elaborate examples, adding labels for axes, rows, columns,
* title and some statistical aggregations.
*
*
*
*
*
* float[][] values = {
{5 ,10, 20, 40 },
{ 7, 8 , 6 , 7 },
{12 ,10, 20, 19 },
{ 3, 1 , 5 , 6 }
};
String title = "CPU performance over time [nops/sec]";
String columnAxisName = "Year";
String rowAxisName = "CPU";
String[] columnNames = {"1996", "1997", "1998", "1999"};
String[] rowNames = { "PowerBar", "Benzol", "Mercedes", "Sparcling"};
hep.aida.bin.BinFunctions1D F = hep.aida.bin.BinFunctions1D.functions; // alias
hep.aida.bin.BinFunction1D[] aggr = {F.mean, F.rms, F.quantile(0.25), F.median, F.quantile(0.75), F.stdDev, F.min, F.max};
String format = "%1.2G";
FloatMatrix2D matrix = new DenseFloatMatrix2D(values);
new Formatter(format).toTitleString(
matrix,rowNames,columnNames,rowAxisName,columnAxisName,title,aggr);
*
*
*
*
*
CPU performance over time [nops/sec]
| Year
| 1996 1997 1998 1999 | Mean RMS 25% Q. Median 75% Q. StdDev Min Max
---------------------------------------------------------------------------------------
C PowerBar | 5 10 20 40 | 18.75 23.05 8.75 15 25 15.48 5 40
P Benzol | 7 8 6 7 | 7 7.04 6.75 7 7.25 0.82 6 8
U Mercedes | 12 10 20 19 | 15.25 15.85 11.5 15.5 19.25 4.99 10 20
Sparcling | 3 1 5 6 | 3.75 4.21 2.5 4 5.25 2.22 1 6
---------------------------------------------------------------------------------------
Mean | 6.75 7.25 12.75 18 |
RMS | 7.53 8.14 14.67 22.62 |
25% Q. | 4.5 6.25 5.75 6.75 |
Median | 6 9 13 13 |
75% Q. | 8.25 10 20 24.25 |
StdDev | 3.86 4.27 8.38 15.81 |
Min | 3 1 5 6 |
Max | 12 10 20 19 |
*
*
* same as above, but now without aggregations
aggr=null;
*
*
* CPU performance over time [nops/sec]
| Year
| 1996 1997 1998 1999
---------------------------------
C PowerBar | 5 10 20 40
P Benzol | 7 8 6 7
U Mercedes | 12 10 20 19
Sparcling | 3 1 5 6
*
*
*
*
* same as above, but now without rows labeled
aggr=null;
rowNames=null;
rowAxisName=null;
*
*
*
*
*
CPU performance over time [nops/sec]
Year
1996 1997 1998 1999
-------------------
5 10 20 40
7 8 6 7
12 10 20 19
3 1 5 6
*
*
*
*
* A column can be broader than specified by the parameter
* minColumnWidth (because a cell may not fit into that width) but a
* column is never smaller than minColumnWidth. Normally one does not
* need to specify minColumnWidth (default is 1). This
* parameter is only interesting when wanting to print two distinct matrices
* such that both matrices have the same column width, for example, to make it
* easier to see which column of matrix A corresponds to which column of matrix
* B.
*
*
*
* Implementation:
*
*
*
* Note that this class is by no means ment to be used for high performance I/O
* (serialization is much quicker). It is ment to produce well human readable
* output.
*
*
* Analyzes the entire matrix before producing output. Each cell is converted to
* a String as indicated by the given C-like format string. If null is
* passed as format string, {@link java.lang.Float#toString(float)} is used
* instead, yielding full precision.
*
*
* Next, leading and trailing whitespaces are removed. For each column the
* maximum number of characters before and after the decimal point is
* determined. (No problem if decimal points are missing). Each cell is then
* padded with leading and trailing blanks, as necessary to achieve decimal
* point aligned, left justified formatting.
*
*
* @author [email protected]
* @version 1.2, 11/30/99
*/
public class FloatFormatter extends AbstractFormatter {
private static final long serialVersionUID = 1L;
/**
* Constructs and returns a matrix formatter with format "%G".
*/
public FloatFormatter() {
this("%G");
}
/**
* Constructs and returns a matrix formatter.
*
* @param format
* the given format used to convert a single cell value.
*/
public FloatFormatter(String format) {
setFormat(format);
setAlignment(DECIMAL);
}
/**
* Demonstrates how to use this class.
*/
public static void demo1() {
// parameters
float[][] values = { { 3, 0, -3.4f, 0 }, { 5.1f, 0, +3.0123456789f, 0 }, { 16.37f, 0.0f, 2.5f, 0 },
{ -16.3f, 0, -3.012345678E-4f, -1 }, { 1236.3456789f, 0, 7, -1.2f } };
String[] formats = { "%G", "%1.10G", "%f", "%1.2f", "%0.2e", null };
// now the processing
int size = formats.length;
FloatMatrix2D matrix = cern.colt.matrix.tfloat.FloatFactory2D.dense.make(values);
String[] strings = new String[size];
String[] sourceCodes = new String[size];
for (int i = 0; i < size; i++) {
String format = formats[i];
strings[i] = new FloatFormatter(format).toString(matrix);
sourceCodes[i] = new FloatFormatter(format).toSourceCode(matrix);
}
System.out.println("original:\n" + new FloatFormatter().toString(matrix));
for (int i = 0; i < size; i++) {
System.out.println("\nstring(" + formats[i] + "):\n" + strings[i]);
System.out.println("\nsourceCode(" + formats[i] + "):\n" + sourceCodes[i]);
}
}
/**
* Demonstrates how to use this class.
*/
public static void demo2() {
// parameters
float[] values = {
// 5, 0.0, -0.0, -Float.NaN, Float.NaN, 0.0/0.0,
// Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY,
// Float.MIN_VALUE,
// Float.MAX_VALUE
5, 0.0f, -0.0f, -Float.NaN, Float.NaN, 0.0f / 0.0f, Float.MIN_VALUE, Float.MAX_VALUE,
Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY
// Float.MIN_VALUE, Float.MAX_VALUE //, Float.NEGATIVE_INFINITY,
// Float.POSITIVE_INFINITY
};
// String[] formats = {"%G", "%1.10G", "%f", "%1.2f", "%0.2e"};
String[] formats = { "%G", "%1.19G" };
// now the processing
int size = formats.length;
FloatMatrix1D matrix = new DenseFloatMatrix1D(values);
String[] strings = new String[size];
// String[] javaStrings = new String[size];
for (int i = 0; i < size; i++) {
String format = formats[i];
strings[i] = new FloatFormatter(format).toString(matrix);
for (int j = 0; j < matrix.size(); j++) {
System.out.println(String.valueOf(matrix.get(j)));
}
}
System.out.println("original:\n" + new FloatFormatter().toString(matrix));
for (int i = 0; i < size; i++) {
System.out.println("\nstring(" + formats[i] + "):\n" + strings[i]);
}
}
/**
* Demonstrates how to use this class.
*/
public static void demo3(int size, float value) {
cern.colt.Timer timer = new cern.colt.Timer();
String s;
StringBuffer buf;
FloatMatrix2D matrix = cern.colt.matrix.tfloat.FloatFactory2D.dense.make(size, size, value);
timer.reset().start();
buf = new StringBuffer();
for (int i = size; --i >= 0;) {
for (int j = size; --j >= 0;) {
buf.append(matrix.getQuick(i, j));
}
}
buf = null;
timer.stop().display();
timer.reset().start();
cern.colt.matrix.Former format = new cern.colt.matrix.FormerFactory().create("%G");
buf = new StringBuffer();
for (int i = size; --i >= 0;) {
for (int j = size; --j >= 0;) {
buf.append(format.form(matrix.getQuick(i, j)));
}
}
buf = null;
timer.stop().display();
timer.reset().start();
s = new FloatFormatter(null).toString(matrix);
System.out.println(s);
s = null;
timer.stop().display();
timer.reset().start();
s = new FloatFormatter("%G").toString(matrix);
System.out.println(s);
s = null;
timer.stop().display();
}
/**
* Demonstrates how to use this class.
*/
public static void demo4() {
// parameters
float[][] values = { { 3, 0, -3.4f, 0 }, { 5.1f, 0, +3.0123456789f, 0 }, { 16.37f, 0.0f, 2.5f, 0 },
{ -16.3f, 0, -3.012345678E-4f, -1 }, { 1236.3456789f, 0, 7, -1.2f } };
/*
* float[][] values = { {3, 1, }, {5.1 ,16.37, } };
*/
// String[] columnNames = { "he", "", "he", "four" };
// String[] rowNames = { "hello", "du", null, "abcdef", "five" };
String[] columnNames = { "0.1", "0.3", "0.5", "0.7" };
String[] rowNames = { "SunJDK1.2.2 classic", "IBMJDK1.1.8", "SunJDK1.3 Hotspot", "other1", "other2" };
// String[] columnNames = { "0.1", "0.3" };
// String[] rowNames = { "SunJDK1.2.2 classic", "IBMJDK1.1.8"};
FloatMatrix2D matrix = cern.colt.matrix.tfloat.FloatFactory2D.dense.make(values);
System.out.println("\n\n"
+ new FloatFormatter("%G").toTitleString(matrix, rowNames, columnNames, "rowAxis", "colAxis",
"VM Performance: Provider vs. matrix density"));
}
/**
* Demonstrates how to use this class.
*/
public static void demo5() {
// parameters
float[][] values = { { 3, 0, -3.4f, 0 }, { 5.1f, 0, +3.0123456789f, 0 }, { 16.37f, 0.0f, 2.5f, 0 },
{ -16.3f, 0, -3.012345678E-4f, -1 }, { 1236.3456789f, 0, 7, -1.2f } };
/*
* float[][] values = { {3, 1, }, {5.1 ,16.37, } };
*/
// String[] columnNames = { "he", "", "he", "four" };
// String[] rowNames = { "hello", "du", null, "abcdef", "five" };
String[] columnNames = { "0.1", "0.3", "0.5", "0.7" };
String[] rowNames = { "SunJDK1.2.2 classic", "IBMJDK1.1.8", "SunJDK1.3 Hotspot", "other1", "other2" };
// String[] columnNames = { "0.1", "0.3" };
// String[] rowNames = { "SunJDK1.2.2 classic", "IBMJDK1.1.8"};
System.out.println(cern.colt.matrix.tfloat.FloatFactory2D.dense.make(values));
System.out.println(new FloatFormatter("%G").toTitleString(cern.colt.matrix.tfloat.FloatFactory2D.dense
.make(values), rowNames, columnNames, "vendor", "density", "title"));
}
/**
* Demonstrates how to use this class.
*/
public static void demo6() {
// parameters
float[][] values = { { 3, 0, -3.4f, 0 }, { 5.1f, 0, +3.0123456789f, 0 }, { 16.37f, 0.0f, 2.5f, 0 },
{ -16.3f, 0, -3.012345678E-4f, -1 }, { 1236.3456789f, 0, 7, -1.2f } };
/*
* float[][] values = { {3, 1, }, {5.1 ,16.37, } };
*/
// String[] columnNames = { "he", "", "he", "four" };
// String[] rowNames = { "hello", "du", null, "abcdef", "five" };
// String[] columnNames = { "0.1", "0.3", "0.5", "0.7" };
String[] columnNames = { "W", "X", "Y", "Z" };
String[] rowNames = { "SunJDK1.2.2 classic", "IBMJDK1.1.8", "SunJDK1.3 Hotspot", "other1", "other2" };
// String[] columnNames = { "0.1", "0.3" };
// String[] rowNames = { "SunJDK1.2.2 classic", "IBMJDK1.1.8"};
// System.out.println(cern.colt.matrix.FloatFactory2D.dense.make(values));
// System.out.println(new
// Formatter().toSourceCode(cern.colt.matrix.FloatFactory2D.dense.make(values)));
System.out.println(new FloatFormatter().toString(cern.colt.matrix.tfloat.FloatFactory2D.dense.make(values)));
System.out.println(new FloatFormatter().toTitleString(
cern.colt.matrix.tfloat.FloatFactory2D.dense.make(values), rowNames, columnNames, "vendor", "density",
"title"));
}
/**
* Demonstrates how to use this class.
*/
public static void demo7() {
float[][] values = { { 5, 10, 20, 40 }, { 7, 8, 6, 7 }, { 12, 10, 20, 19 }, { 3, 1, 5, 6 } };
String[] columnNames = { "1996", "1997", "1998", "1999" };
String[] rowNames = { "PowerBar", "Benzol", "Mercedes", "Sparcling" };
String rowAxisName = "CPU";
String columnAxisName = "Year";
String title = "CPU performance over time [nops/sec]";
hep.aida.tfloat.bin.FloatBinFunctions1D F = hep.aida.tfloat.bin.FloatBinFunctions1D.functions;
hep.aida.tfloat.bin.FloatBinFunction1D[] aggr = { F.mean, F.rms, F.quantile(0.25f), F.median,
F.quantile(0.75f), F.stdDev, F.min, F.max };
String format = "%1.2G";
System.out.println(new FloatFormatter(format).toTitleString(cern.colt.matrix.tfloat.FloatFactory2D.dense
.make(values), rowNames, columnNames, rowAxisName, columnAxisName, title, aggr));
}
/**
* Converts a given cell to a String; no alignment considered.
*/
protected String form(FloatMatrix1D matrix, int index, Former formatter) {
return formatter.form(matrix.get(index));
}
/**
* Converts a given cell to a String; no alignment considered.
*/
protected String form(AbstractMatrix1D matrix, int index, Former formatter) {
return this.form((FloatMatrix1D) matrix, index, formatter);
}
/**
* Returns a string representations of all cells; no alignment considered.
*/
public String[][] format(FloatMatrix2D matrix) {
String[][] strings = new String[matrix.rows()][matrix.columns()];
for (int row = matrix.rows(); --row >= 0;)
strings[row] = formatRow(matrix.viewRow(row));
return strings;
}
/**
* Returns a string representations of all cells; no alignment considered.
*/
protected String[][] format(AbstractMatrix2D matrix) {
return this.format((FloatMatrix2D) matrix);
}
/**
* Returns the index of the decimal point.
*/
protected int indexOfDecimalPoint(String s) {
int i = s.lastIndexOf('.');
if (i < 0)
i = s.lastIndexOf('e');
if (i < 0)
i = s.lastIndexOf('E');
if (i < 0)
i = s.length();
return i;
}
/**
* Returns the number of characters before the decimal point.
*/
protected int lead(String s) {
if (alignment.equals(DECIMAL))
return indexOfDecimalPoint(s);
return super.lead(s);
}
/**
* Returns a string s such that Object[] m = s is a legal
* Java statement.
*
* @param matrix
* the matrix to format.
*/
public String toSourceCode(FloatMatrix1D matrix) {
FloatFormatter copy = (FloatFormatter) this.clone();
copy.setPrintShape(false);
copy.setColumnSeparator(", ");
String lead = "{";
String trail = "};";
return lead + copy.toString(matrix) + trail;
}
/**
* Returns a string s such that Object[] m = s is a legal
* Java statement.
*
* @param matrix
* the matrix to format.
*/
public String toSourceCode(FloatMatrix2D matrix) {
FloatFormatter copy = (FloatFormatter) this.clone();
String b3 = blanks(3);
copy.setPrintShape(false);
copy.setColumnSeparator(", ");
copy.setRowSeparator("},\n" + b3 + "{");
String lead = "{\n" + b3 + "{";
String trail = "}\n};";
return lead + copy.toString(matrix) + trail;
}
/**
* Returns a string s such that Object[] m = s is a legal
* Java statement.
*
* @param matrix
* the matrix to format.
*/
public String toSourceCode(FloatMatrix3D matrix) {
FloatFormatter copy = (FloatFormatter) this.clone();
String b3 = blanks(3);
String b6 = blanks(6);
copy.setPrintShape(false);
copy.setColumnSeparator(", ");
copy.setRowSeparator("},\n" + b6 + "{");
copy.setSliceSeparator("}\n" + b3 + "},\n" + b3 + "{\n" + b6 + "{");
String lead = "{\n" + b3 + "{\n" + b6 + "{";
String trail = "}\n" + b3 + "}\n}";
return lead + copy.toString(matrix) + trail;
}
/**
* Returns a string representation of the given matrix.
*
* @param matrix
* the matrix to convert.
*/
public String toString(FloatMatrix1D matrix) {
FloatMatrix2D easy = matrix.like2D(1, (int) matrix.size());
easy.viewRow(0).assign(matrix);
return toString(easy);
}
/**
* Returns a string representation of the given matrix.
*
* @param matrix
* the matrix to convert.
*/
public String toString(FloatMatrix2D matrix) {
return super.toString(matrix);
}
/**
* Returns a string representation of the given matrix.
*
* @param matrix
* the matrix to convert.
*/
public String toString(FloatMatrix3D matrix) {
StringBuffer buf = new StringBuffer();
boolean oldPrintShape = this.printShape;
this.printShape = false;
for (int slice = 0; slice < matrix.slices(); slice++) {
if (slice != 0)
buf.append(sliceSeparator);
buf.append(toString(matrix.viewSlice(slice)));
}
this.printShape = oldPrintShape;
if (printShape)
buf.insert(0, shape(matrix) + "\n");
return buf.toString();
}
/**
* Returns a string representation of the given matrix.
*
* @param matrix
* the matrix to convert.
*/
protected String toString(AbstractMatrix2D matrix) {
return this.toString((FloatMatrix2D) matrix);
}
/**
* Returns a string representation of the given matrix with axis as well as
* rows and columns labeled. Pass null to one or more parameters to
* indicate that the corresponding decoration element shall not appear in
* the string converted matrix.
*
* @param matrix
* The matrix to format.
* @param rowNames
* The headers of all rows (to be put to the left of the matrix).
* @param columnNames
* The headers of all columns (to be put to above the matrix).
* @param rowAxisName
* The label of the y-axis.
* @param columnAxisName
* The label of the x-axis.
* @param title
* The overall title of the matrix to be formatted.
* @return the matrix converted to a string.
*/
protected String toTitleString(FloatMatrix2D matrix, String[] rowNames, String[] columnNames, String rowAxisName,
String columnAxisName, String title) {
if (matrix.size() == 0)
return "Empty matrix";
String[][] s = format(matrix);
// String oldAlignment = this.alignment;
// this.alignment = DECIMAL;
align(s);
// this.alignment = oldAlignment;
return new cern.colt.matrix.tobject.algo.ObjectFormatter().toTitleString(
cern.colt.matrix.tobject.ObjectFactory2D.dense.make(s), rowNames, columnNames, rowAxisName,
columnAxisName, title);
}
/**
* Same as toTitleString except that additionally statistical
* aggregates (mean, median, sum, etc.) of rows and columns are printed.
* Pass null to one or more parameters to indicate that the
* corresponding decoration element shall not appear in the string converted
* matrix.
*
* @param matrix
* The matrix to format.
* @param rowNames
* The headers of all rows (to be put to the left of the matrix).
* @param columnNames
* The headers of all columns (to be put to above the matrix).
* @param rowAxisName
* The label of the y-axis.
* @param columnAxisName
* The label of the x-axis.
* @param title
* The overall title of the matrix to be formatted.
* @param aggr
* the aggregation functions to be applied to columns and rows.
* @return the matrix converted to a string.
* @see hep.aida.tfloat.bin.FloatBinFunction1D
* @see hep.aida.tfloat.bin.FloatBinFunctions1D
*/
public String toTitleString(FloatMatrix2D matrix, String[] rowNames, String[] columnNames, String rowAxisName,
String columnAxisName, String title, hep.aida.tfloat.bin.FloatBinFunction1D[] aggr) {
if (matrix.size() == 0)
return "Empty matrix";
if (aggr == null || aggr.length == 0)
return toTitleString(matrix, rowNames, columnNames, rowAxisName, columnAxisName, title);
FloatMatrix2D rowStats = matrix.like(matrix.rows(), aggr.length); // hold
// row
// aggregations
FloatMatrix2D colStats = matrix.like(aggr.length, matrix.columns()); // hold
// column
// aggregations
cern.colt.matrix.tfloat.algo.FloatStatistic.aggregate(matrix, aggr, colStats); // aggregate
// an
// entire
// column
// at a
// time
cern.colt.matrix.tfloat.algo.FloatStatistic.aggregate(matrix.viewDice(), aggr, rowStats.viewDice()); // aggregate
// an
// entire
// row
// at a
// time
// turn into strings
// tmp holds "matrix" plus "colStats" below (needed so that numbers in a
// columns can be decimal point aligned)
FloatMatrix2D tmp = matrix.like(matrix.rows() + aggr.length, matrix.columns());
tmp.viewPart(0, 0, matrix.rows(), matrix.columns()).assign(matrix);
tmp.viewPart(matrix.rows(), 0, aggr.length, matrix.columns()).assign(colStats);
colStats = null;
String[][] s1 = format(tmp);
align(s1);
tmp = null;
String[][] s2 = format(rowStats);
align(s2);
rowStats = null;
// copy strings into a large matrix holding the source matrix and all
// aggregations
cern.colt.matrix.tobject.ObjectMatrix2D allStats = cern.colt.matrix.tobject.ObjectFactory2D.dense.make(matrix
.rows()
+ aggr.length, matrix.columns() + aggr.length + 1);
allStats.viewPart(0, 0, matrix.rows() + aggr.length, matrix.columns()).assign(s1);
allStats.viewColumn(matrix.columns()).assign("|");
allStats.viewPart(0, matrix.columns() + 1, matrix.rows(), aggr.length).assign(s2);
s1 = null;
s2 = null;
// append a vertical "|" separator plus names of aggregation functions
// to line holding columnNames
if (columnNames != null) {
cern.colt.list.tobject.ObjectArrayList list = new cern.colt.list.tobject.ObjectArrayList(columnNames);
list.add("|");
for (int i = 0; i < aggr.length; i++)
list.add(aggr[i].name()); // add names of aggregation
// functions
columnNames = new String[list.size()];
list.toArray(columnNames);
}
// append names of aggregation functions to line holding rowNames
if (rowNames != null) {
cern.colt.list.tobject.ObjectArrayList list = new cern.colt.list.tobject.ObjectArrayList(rowNames);
for (int i = 0; i < aggr.length; i++)
list.add(aggr[i].name()); // add names of aggregation
// functions
rowNames = new String[list.size()];
list.toArray(rowNames);
}
// turn large matrix into string
String s = new cern.colt.matrix.tobject.algo.ObjectFormatter().toTitleString(allStats, rowNames, columnNames,
rowAxisName, columnAxisName, title);
// insert a horizontal "----------------------" separation line above
// the column stats
// determine insertion position and line width
int last = s.length() + 1;
int secondLast = last;
int v = Math.max(0, rowAxisName == null ? 0 : rowAxisName.length() - matrix.rows() - aggr.length);
for (int k = 0; k < aggr.length + 1 + v; k++) { // scan
// "aggr.length+1+v"
// lines backwards
secondLast = last;
last = s.lastIndexOf(rowSeparator, last - 1);
}
StringBuffer buf = new StringBuffer(s);
buf.insert(secondLast, rowSeparator + repeat('-', secondLast - last - 1));
return buf.toString();
}
/**
* Returns a string representation of the given matrix with axis as well as
* rows and columns labeled. Pass null to one or more parameters to
* indicate that the corresponding decoration element shall not appear in
* the string converted matrix.
*
* @param matrix
* The matrix to format.
* @param sliceNames
* The headers of all slices (to be put above each slice).
* @param rowNames
* The headers of all rows (to be put to the left of the matrix).
* @param columnNames
* The headers of all columns (to be put to above the matrix).
* @param sliceAxisName
* The label of the z-axis (to be put above each slice).
* @param rowAxisName
* The label of the y-axis.
* @param columnAxisName
* The label of the x-axis.
* @param title
* The overall title of the matrix to be formatted.
* @param aggr
* the aggregation functions to be applied to columns, rows.
* @return the matrix converted to a string.
* @see hep.aida.tfloat.bin.FloatBinFunction1D
* @see hep.aida.tfloat.bin.FloatBinFunctions1D
*/
public String toTitleString(FloatMatrix3D matrix, String[] sliceNames, String[] rowNames, String[] columnNames,
String sliceAxisName, String rowAxisName, String columnAxisName, String title,
hep.aida.tfloat.bin.FloatBinFunction1D[] aggr) {
if (matrix.size() == 0)
return "Empty matrix";
StringBuffer buf = new StringBuffer();
for (int i = 0; i < matrix.slices(); i++) {
if (i != 0)
buf.append(sliceSeparator);
buf.append(toTitleString(matrix.viewSlice(i), rowNames, columnNames, rowAxisName, columnAxisName, title
+ "\n" + sliceAxisName + "=" + sliceNames[i], aggr));
}
return buf.toString();
}
/**
* Returns a string representation of the given matrix with axis as well as
* rows and columns labeled. Pass null to one or more parameters to
* indicate that the corresponding decoration element shall not appear in
* the string converted matrix.
*
* @param matrix
* The matrix to format.
* @param sliceNames
* The headers of all slices (to be put above each slice).
* @param rowNames
* The headers of all rows (to be put to the left of the matrix).
* @param columnNames
* The headers of all columns (to be put to above the matrix).
* @param sliceAxisName
* The label of the z-axis (to be put above each slice).
* @param rowAxisName
* The label of the y-axis.
* @param columnAxisName
* The label of the x-axis.
* @param title
* The overall title of the matrix to be formatted.
* @return the matrix converted to a string.
*/
private String xtoTitleString(FloatMatrix3D matrix, String[] sliceNames, String[] rowNames, String[] columnNames,
String sliceAxisName, String rowAxisName, String columnAxisName, String title) {
if (matrix.size() == 0)
return "Empty matrix";
StringBuffer buf = new StringBuffer();
for (int i = 0; i < matrix.slices(); i++) {
if (i != 0)
buf.append(sliceSeparator);
buf.append(toTitleString(matrix.viewSlice(i), rowNames, columnNames, rowAxisName, columnAxisName, title
+ "\n" + sliceAxisName + "=" + sliceNames[i]));
}
return buf.toString();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy