private void averageArea(int sx, int sy, int radius) {
for (int x = Math.max(0, sx - radius); x < Math.min(m_width, sx + radius); x++) {
for (int y = Math.max(0, sy - radius); y < Math.min(m_height, sy + radius); y++) {
m_contour[x][y] = (m_contour[sx][sy] + m_contour[x][y]) / 2;
}
}
}
private static Map<String, Integer> computeColumnWidths(
final Iterable<CamelContext> camelContexts) throws Exception {
if (camelContexts == null) {
throw new IllegalArgumentException(
"Unable to determine column widths from null Iterable<CamelContext>");
} else {
int maxNameLen = 0;
int maxStatusLen = 0;
int maxUptimeLen = 0;
for (final CamelContext camelContext : camelContexts) {
final String name = camelContext.getName();
maxNameLen = java.lang.Math.max(maxNameLen, name == null ? 0 : name.length());
final String status = camelContext.getStatus().toString();
maxStatusLen = java.lang.Math.max(maxStatusLen, status == null ? 0 : status.length());
final String uptime = camelContext.getUptime();
maxUptimeLen = java.lang.Math.max(maxUptimeLen, uptime == null ? 0 : uptime.length());
}
final Map<String, Integer> retval = new Hashtable<String, Integer>(3);
retval.put(NAME_COLUMN_LABEL, maxNameLen);
retval.put(STATUS_COLUMN_LABEL, maxStatusLen);
retval.put(UPTIME_COLUMN_LABEL, maxUptimeLen);
return retval;
}
}
/**
* Calculates the size of each parition when the proportional partitioning scheme is used.
*
* @param dims represent the logical input space
* @param blockSize the size, in bytes, of the blocks used to store the file that contains the
* data being partitioned
* @param numBlocks the number of blocks to use for generating the per-partition size
* @param fileLen the length of the file, in bytes
* @param dataTypeSize the size, in bytes, of a single cell for the given data type stored in the
* file for which partitions are being generated
* @param conf Configuration object for this current MR program
* @return an int array that is the same length as dims, where each element is the length, in
* cells, that the step shape is in the given dimension
*/
private int[] calcStepShape(
int[] dims,
long blockSize,
long numBlocks,
long fileLen,
int dataTypeSize,
Configuration conf) {
int[] stepShape = new int[dims.length]; // sort out the max space
for (int i = 0; i < dims.length; i++) {
stepShape[i] = dims[i];
}
stepShape[0] = Math.round(Math.max(1, stepShape[0] / numBlocks));
// if holistic functions are turned on, we need to make
// sure this encompasses enough records
// Also need to ensure that it ends up a
// being a multiple of the zero-dimension of extraction shape
if (Utils.queryDependantEnabled(conf)) {
int numExShapesInStep =
Math.max((stepShape[0] / Utils.getExtractionShape(conf, stepShape.length)[0]), 1);
stepShape[0] = numExShapesInStep * Utils.getExtractionShape(conf, stepShape.length)[0];
}
return stepShape;
}
public void drive(double x, double y, double rot) {
l_angle = Math.toDegrees(MathUtils.atan2(-x, -y));
l_magnitude = Math.sqrt((x * x) + (y * y));
forward = y;
right = -x;
clockwise = rot;
// make sure angles are in the expected range
l_angle %= 360;
r_angle %= 360;
if (l_angle < 0) {
l_angle = 360 + l_angle;
}
if (r_angle < 0) {
r_angle = 360 + r_angle;
}
// make sure magnitudes are in range
l_magnitude = Math.max(-1, l_magnitude);
l_magnitude = Math.min(1, l_magnitude);
r_magnitude = Math.max(-1, r_magnitude);
r_magnitude = Math.min(1, r_magnitude);
driveCartesianTest();
}
public void leafLayer(int cx, int cy, int cz, int width) {
for (int x = Math.max(0, cx - width); x < Math.min(m_width, cx + width); x++) {
for (int y = Math.max(0, cy - width); y < Math.min(m_height, cy + width); y++) {
m_blocks[x][y][cz] = BlockConstants.LEAVES;
}
}
}
private double getDistanceTo(double x, double y, double z, Player player) {
double x2 = player.getX();
double y2 = player.getY();
double z2 = player.getZ();
double xResult = java.lang.Math.pow(java.lang.Math.max(x, x2) - java.lang.Math.min(x, x2), 2);
double yResult = java.lang.Math.pow(java.lang.Math.max(y, y2) - java.lang.Math.min(y, y2), 2);
double zResult = java.lang.Math.pow(java.lang.Math.max(z, z2) - java.lang.Math.min(z, z2), 2);
return java.lang.Math.sqrt(xResult + yResult + zResult);
}
public static ArthurImage multiply(ArthurImage one, ArthurImage two) {
BufferedImage image = JavaImageMath.clone(one.bf);
BufferedImage image2 = JavaImageMath.clone(two.bf);
WritableRaster r1 = image.getRaster();
WritableRaster r2 = image2.getRaster();
int newWidth = Math.max(r1.getWidth(), r2.getWidth());
int newHeight = Math.max(r1.getHeight(), r2.getHeight());
BufferedImage collage = new BufferedImage(newWidth, newHeight, BufferedImage.TYPE_INT_RGB);
WritableRaster raster = collage.getRaster();
int[] p1 = new int[3];
int[] p2 = new int[3];
int[] pixelArray = new int[3];
for (int y = 0; y < newHeight; y++) {
for (int x = 0; x < newWidth; x++) {
p1 = null;
p2 = null;
if (x < r1.getWidth() && y < r1.getHeight()) {
p1 = r1.getPixel(x, y, p1);
}
if (x < r2.getWidth() && y < r2.getHeight()) {
p2 = r2.getPixel(x, y, p2);
}
for (int i = 0; i < 3; i++) {
if (p1 == null && p2 == null) {
pixelArray[i] = 0;
} else if (p1 == null && p2 != null) {
pixelArray[i] = p2[i];
} else if (p1 != null && p2 == null) {
pixelArray[i] = p1[i];
} else {
pixelArray[i] = (int) ((p1[i] + p2[i]) / 2);
}
}
raster.setPixel(x, y, pixelArray);
}
}
// save image
String outputFn =
one.filename.substring(0, one.filename.indexOf(".jpg"))
+ "X"
+ // filename can't contain the / or *characters; decide later
two.filename.substring(0, two.filename.indexOf(".jpg"))
+ counter
+ ".jpg";
counter++;
return new ArthurImage(collage, outputFn);
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int minw = getPaddingLeft() + getPaddingRight() + getSuggestedMinimumWidth();
int w = Math.max(minw, MeasureSpec.getSize(widthMeasureSpec));
int minh = getPaddingBottom() + getPaddingTop();
int h = Math.max(minh, MeasureSpec.getSize(heightMeasureSpec));
setMeasuredDimension(w, h);
}
public boolean onToolTouchEvent(MotionEvent event) {
if (mapView == null || mapView.isClickable()) {
return false;
}
Projection pj = editingViewProjection;
// handle drawing
float currentX = event.getX();
float currentY = event.getY();
int action = event.getAction();
switch (action) {
case MotionEvent.ACTION_DOWN:
GeoPoint startGeoPoint = pj.fromPixels(round(currentX), round(currentY));
pj.toPixels(startGeoPoint, startP);
lastX = currentX;
lastY = currentY;
break;
case MotionEvent.ACTION_MOVE:
float dx = currentX - lastX;
float dy = currentY - lastY;
if (abs(dx) < 1 && abs(dy) < 1) {
lastX = currentX;
lastY = currentY;
return true;
}
GeoPoint currentGeoPoint = pj.fromPixels(round(currentX), round(currentY));
pj.toPixels(currentGeoPoint, tmpP);
left = Math.min(tmpP.x, startP.x);
right = Math.max(tmpP.x, startP.x);
bottom = Math.max(tmpP.y, startP.y);
top = Math.min(tmpP.y, startP.y);
rect.set((int) left, (int) top, (int) right, (int) bottom);
EditManager.INSTANCE.invalidateEditingView();
break;
case MotionEvent.ACTION_UP:
float deltaY = abs(top - bottom);
float deltaX = abs(right - left);
if (deltaX > TOUCH_BOX_THRES && deltaY > TOUCH_BOX_THRES) {
GeoPoint ul = pj.fromPixels((int) left, (int) top);
GeoPoint lr = pj.fromPixels((int) right, (int) bottom);
select(ul.getLatitude(), ul.getLongitude(), lr.getLatitude(), lr.getLongitude());
}
break;
}
return true;
}
/**
* Decompress the input stream. The result is left in the a[] array and can be accessed using the
* various get methods.
*/
public void decompress() throws Exception {
decode(); // Launch decoding
undigitize(); // Un-Digitize
if (tmp == null || tmp.length < Math.max(nx, ny)) {
tmp = new int[Math.max(nx, ny)];
flag = new boolean[Math.max(nx, ny)];
}
hinv(); // Inverse H-transform
}
public void setCalculationValues() {
int atom1 = myAtoms[0].getMM3TypeNum();
int atom2 = myAtoms[1].getMM3TypeNum();
int atom3 = myAtoms[2].getMM3TypeNum();
if (atom1 < atom3 || atom1 < 1 || atom2 < 1 || atom3 < 1) {
kBondAngle = 0.0;
return;
}
try {
AtomDataFile dataFile =
new AtomDataFile(newNanocad.txtDir + newNanocad.fileSeparator + "mm3strbenddata.txt");
// AtomDataFile dataFile = new AtomDataFile("mm3strbenddata.txt");
if (dataFile.findData(atom1, 0)) kBondAngle = dataFile.parseDouble(1);
else {
kBondAngle = 0.0;
return;
}
dataFile = new AtomDataFile(newNanocad.txtDir + newNanocad.fileSeparator + "mm3adata.txt");
// dataFile = new AtomDataFile("mm3adata.txt");
if (dataFile.findData(atom2, atom1, atom3, 1, 0, 2))
idealAngle = convert * dataFile.parseDouble(4);
else {
idealAngle = 0.0;
return;
}
dataFile = new AtomDataFile(newNanocad.txtDir + newNanocad.fileSeparator + "mm3ldata.txt");
// dataFile = new AtomDataFile("mm3ldata.txt");
if (dataFile.findData(Math.min(atom1, atom2), Math.max(atom1, atom2), 0, 1))
idealLength1 = dataFile.parseDouble(3);
else {
idealLength1 = 0.0;
return;
}
if (dataFile.findData(Math.min(atom2, atom3), Math.max(atom2, atom3), 0, 1))
idealLength2 = dataFile.parseDouble(3);
else {
idealLength2 = 0.0;
return;
}
} catch (java.io.IOException e) {
System.err.println("Stretch-bend data lookup error");
e.printStackTrace();
}
}
/* Result is the numeric value of the largest value.
*/
public static SchemaTypeNumber max(SchemaTypeNumber value1, SchemaTypeNumber value2) {
switch (java.lang.Math.max(value1.numericType(), value2.numericType())) {
case SchemaTypeNumber.NUMERIC_VALUE_INT:
return new SchemaInt(java.lang.Math.max(value1.intValue(), value2.intValue()));
case SchemaTypeNumber.NUMERIC_VALUE_LONG:
return new SchemaLong(java.lang.Math.max(value1.longValue(), value2.longValue()));
case SchemaTypeNumber.NUMERIC_VALUE_BIGINTEGER:
return new SchemaInteger(value1.bigIntegerValue().max(value2.bigIntegerValue()));
case SchemaTypeNumber.NUMERIC_VALUE_FLOAT:
return new SchemaFloat(java.lang.Math.max(value1.floatValue(), value2.floatValue()));
case SchemaTypeNumber.NUMERIC_VALUE_DOUBLE:
return new SchemaDouble(java.lang.Math.max(value1.doubleValue(), value2.doubleValue()));
}
return new SchemaDecimal(value1.bigDecimalValue().max(value2.bigDecimalValue()));
}
public int maxArea(int[] height) {
int left = 0;
int right = height.length - 1;
int area = 0;
while (left < right) {
if (height[left] < height[right]) {
area = Math.max(area, (right - left) * height[left]);
left++;
} else {
area = Math.max(area, (right - left) * height[right]);
right--;
}
}
return area;
}
/**
* Pushes a new Construct onto the end of the array. If the index is specified, this works like a
* "insert" operation, in that all values are shifted to the right, starting with the value at
* that index. If the array is associative though, you MUST send null, otherwise an {@link
* IllegalArgumentException} is thrown. Ideally, you should use {@link #set} anyways for an
* associative array.
*
* @param c The Construct to add to the array
* @throws IllegalArgumentException If index is not null, and this is an associative array.
* @throws IndexOutOfBoundsException If the index is not null, and the index specified is out of
* range.
*/
public void push(Construct c, Integer index, Target t)
throws IllegalArgumentException, IndexOutOfBoundsException {
if (!associative_mode) {
if (index != null) {
array.add(index, c);
} else {
array.add(c);
}
next_index++;
} else {
if (index != null) {
throw new IllegalArgumentException("Cannot insert into an associative array");
}
int max = 0;
for (String key : associative_array.keySet()) {
try {
int i = Integer.parseInt(key);
max = java.lang.Math.max(max, i);
} catch (NumberFormatException e) {
}
}
if (c instanceof CEntry) {
associative_array.put(Integer.toString(max + 1), ((CEntry) c).construct());
} else {
associative_array.put(Integer.toString(max + 1), c);
}
}
if (c instanceof CArray) {
((CArray) c).parent = this;
}
regenValue(new HashSet<CArray>());
}
public static double Silhouette(
ArrayList<ArrayList<ArrayList<Double>>> clusters, double[][] means) {
/*
* Silhouette is a measurement of how consistent the clusters are
* It measures how tight and spread out the clusters are.
* S(i) = (b(i) - a(i)) / max(b(i),a(i)
* i = a single observation
*/
double s = 0.0;
double s_temp = 0.0;
double a_j = 0.0;
double b_j = 0.0;
for (int i = 0; i < clusters.size(); i++) {
for (int j = 0; j < clusters.get(i).size(); j++) {
a_j = a(clusters, i, j);
b_j = b(clusters, means, i, j);
s_temp += ((b_j - a_j) / Math.max(b_j, a_j));
}
s += s_temp;
s_temp = 0;
}
s = (double) s / (double) clusters.size();
return s;
}
private void startReadTrack() {
setExecutionMode();
clearRegs012();
this.sectorIdCyl = this.args[2];
this.sectorIdHead = this.args[3];
this.sectorIdRec = 1;
this.sectorIdSizeCode = this.args[5];
this.curSectorReader = null;
this.curSectorIdx = 0;
this.tcEnabled = true;
boolean done = false;
FloppyDiskDrive drive = getArgDrive();
if (drive != null) {
if (drive.isReady()) {
this.dataLen = getArgDataLen();
this.executingDrive = drive;
startIOTask(
IOTaskCmd.READ_SECTOR_BY_INDEX,
Math.max(this.tStatesPerRotation - this.tStateRotationCounter, 0));
done = true;
}
}
if (!done) {
this.statusReg0 |= ST0_ABNORMAL_TERMINATION;
this.statusReg0 |= ST0_EQUIPMENT_CHECK;
this.statusReg0 |= ST0_NOT_READY;
this.statusReg0 |= (this.args[1] & HEAD_DRIVE_MASK);
stopExecution();
}
}
protected static SchemaType getCommonNumberInstance(SchemaType a_value, SchemaType b) {
return (SchemaType)
getCommonNumberInstance(
java.lang.Math.max(
((SchemaTypeNumber) a_value).numericType(), ((SchemaTypeNumber) b).numericType()),
(SchemaTypeNumber) a_value);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int M = sc.nextInt();
int N = sc.nextInt();
int a[][] = new int[M + 1][N + 1];
int dp[][] = new int[M + 1][N + 1];
for (int i = 1; i <= M; i++) {
for (int j = 1; j <= N; j++) {
a[i][j] = sc.nextInt();
if (a[i][j] == 0) a[i][j] = -9999999;
}
}
for (int i = 1; i <= M; i++) {
for (int j = 1; j <= N; j++) {
dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + a[i][j];
}
}
int max = -100000000;
for (int i = 1; i <= M; i++) {
for (int j = 1; j <= N; j++) {
for (int k = 1; k <= M; k++) {
if (i + k > M) break;
else if (j + k > N) break;
int temp = dp[i + k][j + k] - dp[i - 1][j + k] - dp[i + k][j - 1] + dp[i - 1][j - 1];
max = Math.max(max, temp);
}
}
}
System.out.println(max);
}
public CArray(Target t, int initialCapacity, Construct... items) {
super("{}", ConstructType.ARRAY, t);
if (initialCapacity == -1) {
associative_mode = true;
} else if (items != null) {
for (Construct item : items) {
if (item instanceof CEntry) {
// it's an associative array
associative_mode = true;
break;
}
}
}
associative_array = new TreeMap<>(comparator);
array =
associative_mode
? new ArrayList<Construct>()
: initialCapacity > 0
? new ArrayList<Construct>(initialCapacity)
: items != null
? new ArrayList<Construct>(items.length)
: new ArrayList<Construct>();
if (associative_mode) {
if (items != null) {
for (Construct item : items) {
if (item instanceof CEntry) {
associative_array.put(
normalizeConstruct(((CEntry) item).ckey), ((CEntry) item).construct);
} else {
int max = Integer.MIN_VALUE;
for (String key : associative_array.keySet()) {
try {
int i = Integer.parseInt(key);
max = java.lang.Math.max(max, i);
} catch (NumberFormatException e) {
}
}
if (max == Integer.MIN_VALUE) {
max = -1; // Special case, there are no integer indexes in here yet.
}
associative_array.put(Integer.toString(max + 1), item);
if (item instanceof CArray) {
((CArray) item).parent = this;
}
}
}
}
} else {
if (items != null) {
for (Construct item : items) {
array.add(item);
if (item instanceof CArray) {
((CArray) item).parent = this;
}
}
}
this.next_index = array.size();
}
regenValue(new HashSet<CArray>());
}
public static double max(double... vals) {
double max = -Double.MAX_VALUE;
for (double v : vals) {
max = Math.max(v, max);
}
return max;
}
/**
* Compare this package's specification version with a desired version. It returns true if this
* packages specification version number is greater than or equal to the desired version number.
*
* <p>Version numbers are compared by sequentially comparing corresponding components of the
* desired and specification strings. Each component is converted as a decimal integer and the
* values compared. If the specification value is greater than the desired value true is returned.
* If the value is less false is returned. If the values are equal the period is skipped and the
* next pair of components is compared.
*
* @param desired the version string of the desired version.
* @return true if this package's version number is greater than or equal to the desired version
* number
* @exception NumberFormatException if the desired or current version is not of the correct dotted
* form.
*/
public boolean isCompatibleWith(String desired) throws NumberFormatException {
if (specVersion == null || specVersion.length() < 1) {
throw new NumberFormatException("Empty version string");
}
String[] sa = specVersion.split("\\.", -1);
int[] si = new int[sa.length];
for (int i = 0; i < sa.length; i++) {
si[i] = Integer.parseInt(sa[i]);
if (si[i] < 0) throw NumberFormatException.forInputString("" + si[i]);
}
String[] da = desired.split("\\.", -1);
int[] di = new int[da.length];
for (int i = 0; i < da.length; i++) {
di[i] = Integer.parseInt(da[i]);
if (di[i] < 0) throw NumberFormatException.forInputString("" + di[i]);
}
int len = Math.max(di.length, si.length);
for (int i = 0; i < len; i++) {
int d = (i < di.length ? di[i] : 0);
int s = (i < si.length ? si[i] : 0);
if (s < d) return false;
if (s > d) return true;
}
return true;
}
/**
* check if the given position collides with the flashlight.
*
* @param point
* @return
*/
public boolean flashlightCollision(Point2D point) {
flY23 = flY2 - flY3;
flX32 = flX3 - flX2;
flY31 = flY3 - flY1;
flX13 = flX1 - flX3;
flDet = flY23 * flX13 - flX32 * flY31;
flMinD = Math.min(flDet, 0);
flMaxD = Math.max(flDet, 0);
double x = point.getX();
double y = point.getY();
double dx = x - flX3;
double dy = y - flY3;
double a = flY23 * dx + flX32 * dy;
if (a < flMinD || a > flMaxD) {
return false;
}
double b = flY31 * dx + flX13 * dy;
if (b < flMinD || b > flMaxD) {
return false;
}
double c = flDet - a - b;
return !(c < flMinD || c > flMaxD);
}
public void applyContour() {
int maxHeight = 1;
for (int x = 0; x < m_width; x++) {
for (int y = 0; y < m_height; y++) {
if (m_contour[x][y] > maxHeight) maxHeight = m_contour[x][y];
}
}
m_logger.debug("Applying contour");
for (int x = 0; x < m_width; x++) {
for (int y = 0; y < m_height; y++) {
int h = Math.max(0, Math.min(m_depth - 1, (m_depth / 2) + m_contour[x][y]));
// int d = m_random.nextInt(8) - 4;
for (int z = 0; z < m_depth; z++) {
int type = BlockConstants.AIR;
if (z >= h && z < m_depth / 2 - 1) {
type = BlockConstants.WATER;
} else if (z >= h) {
type = BlockConstants.AIR;
} else if (z == (h - 1)) {
type = BlockConstants.GRASS;
} else if (z < (h - 1) && z > (h - 5)) {
type = BlockConstants.DIRT;
} else if (z <= (h - 5)) {
type = BlockConstants.ROCK;
}
m_blocks[x][y][z] = (byte) type;
}
}
}
}
@Override
public void handleCommand(InsteonPLMBindingConfig conf, Command cmd, InsteonDevice dev) {
try {
if (cmd == OnOffType.ON) {
Msg m = dev.makeStandardMessage((byte) 0x0f, (byte) 0x11, (byte) 0xff);
dev.enqueueMessage(m, m_feature);
logger.info("{}: sent msg to switch {} on", nm(), dev.getAddress());
} else if (cmd == OnOffType.OFF) {
Msg m = dev.makeStandardMessage((byte) 0x0f, (byte) 0x13, (byte) 0x00);
dev.enqueueMessage(m, m_feature);
logger.info("{}: sent msg to switch {} off", nm(), dev.getAddress());
}
// This used to be configurable, but was made static to make
// the architecture of the binding cleaner.
int delay = 2000;
delay = Math.max(1000, delay);
delay = Math.min(10000, delay);
Timer timer = new Timer();
timer.schedule(
new TimerTask() {
@Override
public void run() {
Msg m = m_feature.makePollMsg();
InsteonDevice dev = m_feature.getDevice();
if (m != null) dev.enqueueMessage(m, m_feature);
}
},
delay);
} catch (IOException e) {
logger.error("{}: command send i/o error: ", nm(), e);
} catch (FieldException e) {
logger.error("{}: command send message creation error: ", nm(), e);
}
}
private void drawGpsStatus(Graphics g) {
if ((m_fix > 0) && (m_sats >= 0)) {
// Set background to signal quality
g.setColor(GREEN);
} else
// receiving data, but signal ist not good
if ((m_fix == 0) && (m_sats >= 0)) {
g.setColor(YELLOW);
} else {
g.setColor(RED);
}
String strSats = "Sats: -";
if (m_sats >= 0) {
strSats = "Sats: " + Convert.toString(m_sats) + "/" + Convert.toString(m_satsInView);
}
String strHdop = "HDOP: -";
if (m_hdop >= 0) strHdop = "HDOP: " + Convert.toString(m_hdop);
int textWidth = java.lang.Math.max(fm.getTextWidth(strSats), fm.getTextWidth(strHdop));
int startX = location.width - (textWidth + 4);
int startY = location.height - 2 * lineHeight;
g.fillRect(startX, startY, location.width - startX, location.height - startY);
g.setColor(Color.Black);
g.drawText(strSats, startX + 2, startY);
g.drawText(strHdop, startX + 2, startY + lineHeight);
}
public SparseVector(int length, int capacity) {
if (length <= 0) throw new ArithmeticException("Vector must have a positive dimension");
this.used = 0;
capacity = Math.max(capacity, 10);
this.length = length;
this.indexes = new int[capacity];
this.values = new double[capacity];
}
public void postOnNewPicture(Callable<Picture> pictureProvider) {
if (mHasPendingOnNewPicture) return;
mHasPendingOnNewPicture = true;
long pictureTime =
java.lang.Math.max(
mLastPictureTime + ON_NEW_PICTURE_MIN_PERIOD_MILLIS, SystemClock.uptimeMillis());
mHandler.sendMessageAtTime(
mHandler.obtainMessage(MSG_ON_NEW_PICTURE, pictureProvider), pictureTime);
}
@Override
public double max() {
if (maxCache != null) return maxCache;
double result = 0;
for (int i = 0; i < used; i++) result = Math.max(result, values[i]);
return (maxCache = result);
}
private void drawGpsData(Graphics g) {
g.setColor(RED);
String strHeadline = MyLocale.getMsg(1501, "Current");
Double tmp = new Double();
String strSpeed = null;
String unit = null;
// Allow for different metric systems
if (Global.getPref().metricSystem == Metrics.IMPERIAL) {
tmp.set(Metrics.convertUnit(m_speed, Metrics.KILOMETER, Metrics.MILES));
unit = " mph";
strSpeed = "- mph";
} else {
tmp.set(m_speed);
unit = " km/h";
strSpeed = "- km/h";
}
if (tmp.value >= 0) {
if (tmp.value >= 100) {
strSpeed = MyLocale.formatDouble(tmp, "0") + unit;
} else {
strSpeed = MyLocale.formatDouble(tmp, "0.0") + unit;
}
}
tmp.set(moveDir);
String strMoveDir = "---" + " " + MyLocale.getMsg(1502, "deg");
if ((tmp.value <= 360) && (tmp.value >= -360))
strMoveDir = tmp.toString(0, 0, 0) + " " + MyLocale.getMsg(1502, "deg");
int textWidth = java.lang.Math.max(fm.getTextWidth(strSpeed), fm.getTextWidth(strMoveDir));
textWidth = java.lang.Math.max(textWidth, fm.getTextWidth(strHeadline));
int startX = location.width - (textWidth + 4);
g.fillRect(startX, 0, location.width - startX, lineHeight);
g.setColor(Color.Black);
g.drawText(strHeadline, startX + 2, 0);
g.drawText(strSpeed, startX + 2, lineHeight);
g.drawText(strMoveDir, startX + 2, 2 * lineHeight);
}
@Override
public Vec clone() {
SparseVector copy = new SparseVector(length, Math.max(used, 10));
System.arraycopy(this.values, 0, copy.values, 0, this.used);
System.arraycopy(this.indexes, 0, copy.indexes, 0, this.used);
copy.used = this.used;
return copy;
}
