public static void main(String[] args) throws IOException {
in = new Reader();
out = new PrintWriter(System.out, true);
for (; ; ) {
int n = in.nextInt();
if (n == 0) break;
int[] arr1 = new int[n];
for (int i = 0; i < n; i++) arr1[i] = in.nextInt();
int m = in.nextInt();
int[] arr2 = new int[m];
for (int i = 0; i < m; i++) arr2[i] = in.nextInt();
int idx1 = 0, idx2 = 0, sum1 = 0, sum2 = 0, sum = 0;
for (; ; ) {
sum1 += arr1[idx1];
while (idx2 < m && arr1[idx1] > arr2[idx2]) sum2 += arr2[idx2++];
if (idx2 == m) {
idx1++;
break;
}
if (arr1[idx1] == arr2[idx2]) {
sum2 += arr2[idx2++];
sum += Math.max(sum1, sum2);
sum1 = sum2 = 0;
}
idx1++;
if (idx1 == n) break;
}
while (idx1 < n) sum1 += arr1[idx1++];
while (idx2 < m) sum2 += arr2[idx2++];
sum += Math.max(sum1, sum2);
out.println(sum);
}
}
/**
* Skip bytes. This method will block until some bytes are available, an I/O error occurs, or
* the end of the stream is reached.
*
* @param n The number of bytes to skip
* @return The number of bytes actually skipped
* @throws IllegalArgumentException if n is negative.
* @throws IOException if the stream is closed.
* @since ostermillerutils 1.00.00
*/
@Override
public long skip(long n) throws IOException, IllegalArgumentException {
while (true) {
synchronized (CircularByteBuffer.this) {
if (inputStreamClosed)
throw new IOException(
"InputStream has been closed; cannot skip bytes on a closed InputStream.");
int available = CircularByteBuffer.this.available();
if (available > 0) {
int length = Math.min((int) n, available);
int firstLen = Math.min(length, buffer.length - readPosition);
int secondLen = length - firstLen;
if (secondLen > 0) {
readPosition = secondLen;
} else {
readPosition += length;
}
if (readPosition == buffer.length) {
readPosition = 0;
}
ensureMark();
return length;
} else if (outputStreamClosed) {
return 0;
}
}
try {
Thread.sleep(100);
} catch (Exception x) {
throw new IOException("Blocking read operation interrupted.");
}
}
}
// Returns the distance between two planets, rounded up to the next highest
// integer. This is the number of discrete time steps it takes to get
// between the two planets.
public int Distance(int sourcePlanet, int destinationPlanet) {
Planet source = planets.get(sourcePlanet);
Planet destination = planets.get(destinationPlanet);
double dx = source.X() - destination.X();
double dy = source.Y() - destination.Y();
return (int) Math.ceil(Math.sqrt(dx * dx + dy * dy));
}
public double nextDouble() {
int c = read();
while (isSpaceChar(c)) c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.') {
if (c == 'e' || c == 'E') return res * Math.pow(10, nextInt());
if (c < '0' || c > '9') throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
if (c == '.') {
c = read();
double m = 1;
while (!isSpaceChar(c)) {
if (c == 'e' || c == 'E') return res * Math.pow(10, nextInt());
if (c < '0' || c > '9') throw new InputMismatchException();
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
public double getShapeRatio(double ratio, int shape) {
switch (shape) {
// case CONICAL: return 0.2+0.8*ratio;
// need real conical shape for lark, fir, etc.
case CONICAL:
return ratio; // FIXME: this would be better: 0.05+0.95*ratio; ?
case SPHERICAL:
return 0.2 + 0.8 * Math.sin(Math.PI * ratio);
case HEMISPHERICAL:
return 0.2 + 0.8 * Math.sin(0.5 * Math.PI * ratio);
case CYLINDRICAL:
return 1.0;
case TAPERED_CYLINDRICAL:
return 0.5 + 0.5 * ratio;
case FLAME:
return ratio <= 0.7 ? ratio / 0.7 : (1 - ratio) / 0.3;
case INVERSE_CONICAL:
return 1 - 0.8 * ratio;
case TEND_FLAME:
return ratio <= 0.7 ? 0.5 + 0.5 * ratio / 0.7 : 0.5 + 0.5 * (1 - ratio) / 0.3;
case ENVELOPE:
if (ratio < 0 || ratio > 1) {
return 0;
} else if (ratio < (1 - PruneWidthPeak)) {
return Math.pow(ratio / (1 - PruneWidthPeak), PrunePowerHigh);
} else {
return Math.pow((1 - ratio) / (1 - PruneWidthPeak), PrunePowerLow);
}
// tested in prepare() default: throw new ErrorParam("Shape must be between 0 and 8");
}
return 0; // shouldn't reach here
}
void go3(int x, int y, int v, int at) {
if (at == -1) return;
if (y < a[at] || x > b[at]) return;
val[at] += (Math.min(b[at], y) - Math.max(a[at], x) + 1) * v;
go3(x, y, v, left[at]);
go3(x, y, v, right[at]);
}
private void renderBlackout(Graphics g, int x, int y, int radius) {
if (radius > 320) return;
int[] xp = new int[20];
int[] yp = new int[20];
for (int i = 0; i < 16; i++) {
xp[i] = x + (int) (Math.cos(i * Math.PI / 15) * radius);
yp[i] = y + (int) (Math.sin(i * Math.PI / 15) * radius);
}
xp[16] = 320;
yp[16] = y;
xp[17] = 320;
yp[17] = 240;
xp[18] = 0;
yp[18] = 240;
xp[19] = 0;
yp[19] = y;
g.fillPolygon(xp, yp, xp.length);
for (int i = 0; i < 16; i++) {
xp[i] = x - (int) (Math.cos(i * Math.PI / 15) * radius);
yp[i] = y - (int) (Math.sin(i * Math.PI / 15) * radius);
}
xp[16] = 320;
yp[16] = y;
xp[17] = 320;
yp[17] = 0;
xp[18] = 0;
yp[18] = 0;
xp[19] = 0;
yp[19] = y;
g.fillPolygon(xp, yp, xp.length);
}
/**
* Calculates the difference
*
* @return difference
*/
public double prototypeDifference(CombStat stat) {
double sumdiff = 0;
double weight;
// Numeric atts: abs difference
for (int i = 0; i < m_RegStat.getNbNumericAttributes(); i++) {
weight = m_StatManager.getClusteringWeights().getWeight(m_RegStat.getAttribute(i));
sumdiff += Math.abs(prototypeNum(i) - stat.prototypeNum(i)) * weight;
// System.err.println("sumdiff: " + Math.abs(prototypeNum(i) - stat.prototypeNum(i)) *
// weight);
}
// Nominal atts: Manhattan distance
for (int i = 0; i < m_ClassStat.getNbNominalAttributes(); i++) {
weight = m_StatManager.getClusteringWeights().getWeight(m_ClassStat.getAttribute(i));
double sum = 0;
double[] proto1 = prototypeNom(i);
double[] proto2 = stat.prototypeNom(i);
for (int j = 0; j < proto1.length; j++) {
sum += Math.abs(proto1[j] - proto2[j]);
}
sumdiff += sum * weight;
// System.err.println("sumdiff: " + (sum * weight));
}
// System.err.println("sumdiff-total: " + sumdiff);
return sumdiff != 0 ? sumdiff : 0.0;
}
private long calculateExpiry(
URLConnection urlConnection,
long request_time,
UrlConnectionExpiryCalculator urlConnectionExpiryCalculator) {
if ("no-cache".equals(urlConnection.getHeaderField("Pragma"))) {
return 0L;
}
final String cacheControl = urlConnection.getHeaderField("Cache-Control");
if (cacheControl != null) {
if (cacheControl.indexOf("no-cache") != -1) {
return 0L;
}
final int max_age = getMaxAge(cacheControl);
if (-1 != max_age) {
final long response_time = System.currentTimeMillis();
final long apparent_age = Math.max(0, response_time - urlConnection.getDate());
final long corrected_received_age =
Math.max(apparent_age, urlConnection.getHeaderFieldInt("Age", 0) * 1000L);
final long response_delay = response_time - request_time;
final long corrected_initial_age = corrected_received_age + response_delay;
final long creation_time = response_time - corrected_initial_age;
return max_age * 1000L + creation_time;
}
}
final long explicitExpiry = urlConnection.getHeaderFieldDate("Expires", -1L);
if (explicitExpiry != -1L) {
return explicitExpiry;
}
return urlConnectionExpiryCalculator == null
? 0L
: urlConnectionExpiryCalculator.calculateExpiry(urlConnection);
}
@Override
public void trainMostSimilar(List<EnsembleSim> simList) {
if (simList.isEmpty()) {
throw new IllegalStateException("no examples to train on!");
}
mostSimilarInterpolator.trainMostSimilar(simList);
// Remove things that have no observed metrics
List<EnsembleSim> pruned = new ArrayList<EnsembleSim>();
for (EnsembleSim es : simList) {
if (es != null && es.getNumMetricsWithScore() > 0) {
pruned.add(es);
}
}
double[][] X = new double[pruned.size()][numMetrics * 2];
double[] Y = new double[pruned.size()];
for (int i = 0; i < pruned.size(); i++) {
Y[i] = pruned.get(i).knownSim.similarity;
EnsembleSim es = mostSimilarInterpolator.interpolate(pruned.get(i));
for (int j = 0; j < numMetrics; j++) {
X[i][2 * j] = es.getScores().get(j);
X[i][2 * j + 1] = Math.log(es.getRanks().get(j) + 1);
}
}
OLSMultipleLinearRegression regression = new OLSMultipleLinearRegression();
regression.newSampleData(Y, X);
mostSimilarCoefficients = new TDoubleArrayList(regression.estimateRegressionParameters());
double pearson = Math.sqrt(regression.calculateRSquared());
LOG.info("coefficients are " + mostSimilarCoefficients.toString());
LOG.info("pearson for multiple regression is " + pearson);
}
/* Function for calculating laplacePerTerm for individual query terms */
public static double laplacePerTerm(
String termFreq, double docLen, double avgLen, long vocabSize, int queryWords) {
// System.out.println("Query Words:::");
String[] termFs = termFreq.split(" ");
// System.out.println("TermFs::: "+ termFreq);
double log_p_lap = 0.0;
/*
* if(termFs.length <= queryWords){
*
* for(int j=0;j<(queryWords-termFs.length); j++){ log_p_lap +=
* Math.log(((0 + 1) / (docLen + vocabSize)); } log_p_lap+= (Math.log((0
* + 1) / (docLen + vocabSize))) * (queryWords - termFs.length);
*
* }
*/
if (termFs.length < queryWords) {
log_p_lap += (Math.log((0 + 1) / (docLen + vocabSize))) * (queryWords - termFs.length);
}
for (int i = 0; i < termFs.length; i++) {
log_p_lap += Math.log(((Integer.parseInt(termFs[i])) + 1) / (docLen + vocabSize));
}
return log_p_lap;
}
private Rectangle layoutRects() {
int limit = helpers.size();
int visiCount = 0;
int maxHeight = 50;
int maxWidth = 50;
int nextVisibleCol = Integer.MAX_VALUE;
for (int i = 0; i < limit; i++) {
TDHelper thisHelper = helpers.elementAt(i);
if (thisHelper.indentation > nextVisibleCol) {
thisHelper.drawRect = null;
continue;
}
if (thisHelper.subsVisible) {
nextVisibleCol = Integer.MAX_VALUE;
} else {
nextVisibleCol = thisHelper.indentation;
}
thisHelper.layoutRect(visiCount, thisHelper.indentation, auxData);
visiCount++;
maxWidth = Math.max(maxWidth, thisHelper.drawRect.x + thisHelper.drawRect.width);
maxHeight = Math.max(maxHeight, thisHelper.drawRect.y + thisHelper.drawRect.height);
}
Rectangle rtnVal =
new Rectangle(maxWidth + TDHelper.rowPixelBase, maxHeight + TDHelper.colPixelBase);
this.setSize(Math.max(500, rtnVal.width), Math.max(500, rtnVal.height));
return rtnVal;
}
/**
* Updates all the statistics for the current itemset.
*
* @param predictedClassification Distribution of class values predicted for the itemset.
* @param itemset The itemset.
* @param nClasses The number of classes.
*/
private void updateStats(double[] predictedClassification, Itemset itemset, int nClasses) {
int actualClass = (int) itemset.getClassValue();
if (!itemset.classIsMissing()) {
updateMargins(predictedClassification, actualClass, nClasses);
// Determine the predicted class (doesn't detect multiple classifications)
int predictedClass = -1;
double bestProb = 0.0;
for (int i = 0; i < nClasses; i++) {
if (predictedClassification[i] > bestProb) {
predictedClass = i;
bestProb = predictedClassification[i];
}
}
// Update counts when no class was predicted
if (predictedClass < 0) {
return;
}
double predictedProb = Math.max(Double.MIN_VALUE, predictedClassification[actualClass]);
double priorProb =
Math.max(Double.MIN_VALUE, priorsProbabilities[actualClass] / classPriorsSum);
}
}
private static void solve(int[][] points) {
int N = points.length;
int W = (1 << N);
int[][] dp = new int[N][W];
int[][] masks = new int[N][N];
int[][] areas = new int[N][N];
makeMasksAndAreas(points, masks, areas);
for (int i = 0; i < N; i++) {
Arrays.fill(dp[i], Integer.MAX_VALUE);
}
dp[0][0] = 0;
for (int i = 1; i < N; i++) {
for (int state = 0; state < W; state++) {
if (dp[i - 1][state] == Integer.MAX_VALUE) continue;
for (int a = 0; a < N; a++) {
for (int b = a + 1; b < N; b++) {
int mask = masks[a][b];
if ((mask | state) == state) continue;
dp[i][mask | state] = Math.min(dp[i][mask | state], dp[i - 1][state] + areas[a][b]);
}
}
}
}
int res = Integer.MAX_VALUE;
for (int i = 0; i < N; i++) {
res = Math.min(res, dp[i][W - 1]);
}
System.out.println(res);
}
void run() {
InputReader in = new InputReader(System.in);
PrintWriter out = new PrintWriter(System.out);
int n = in.nextInt(), q = in.nextInt();
int[] v = new int[n], c = new int[n];
for (int i = 0; i < n; ++i) v[i] = in.nextInt();
for (int i = 0; i < n; ++i) c[i] = in.nextInt();
for (int i = 0; i < q; ++i) {
int a = in.nextInt(), b = in.nextInt();
long[] dp = new long[n + 1];
Node[] heap = new Node[2];
Arrays.fill(dp, -INF);
for (int j = 0; j < 2; ++j) heap[j] = new Node(-INF, -1);
for (int j = 0; j < n; ++j) {
long val = v[j], maxv = val * b;
int color = c[j];
maxv = Math.max(dp[color] + val * a, maxv);
maxv = Math.max(choose(heap, color) + val * b, maxv);
dp[color] = Math.max(maxv, dp[color]);
update(heap, dp[color], color);
}
long ret = 0;
for (int j = 1; j <= n; ++j) ret = Math.max(ret, dp[j]);
out.println(ret);
}
out.close();
}
/**
* Writes the <code>shape</code>, <code>coords</code>, <code>href</code>,
* <code>nohref</code> Attribute for the specified figure and ellipse.
*
* @return Returns true, if the circle is inside of the image bounds.
*/
private boolean writeCircleAttributes(IXMLElement elem, SVGFigure f, Ellipse2D.Double ellipse) {
AffineTransform t = TRANSFORM.getClone(f);
if (t == null) {
t = drawingTransform;
} else {
t.preConcatenate(drawingTransform);
}
if ((t.getType() &
(AffineTransform.TYPE_UNIFORM_SCALE | AffineTransform.TYPE_TRANSLATION)) ==
t.getType() &&
ellipse.width == ellipse.height
) {
Point2D.Double start = new Point2D.Double(ellipse.x, ellipse.y);
Point2D.Double end = new Point2D.Double(ellipse.x + ellipse.width, ellipse.y + ellipse.height);
t.transform(start, start);
t.transform(end, end);
ellipse.x = Math.min(start.x, end.x);
ellipse.y = Math.min(start.y, end.y);
ellipse.width = Math.abs(start.x - end.x);
ellipse.height = Math.abs(start.y - end.y);
elem.setAttribute("shape", "circle");
elem.setAttribute("coords",
(int) (ellipse.x + ellipse.width / 2d)+","+
(int) (ellipse.y + ellipse.height / 2d)+","+
(int) (ellipse.width / 2d)
);
writeHrefAttribute(elem, f);
return bounds.intersects(ellipse.getBounds());
} else {
return writePolyAttributes(elem, f, (Shape) ellipse);
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
int t = in.nextInt();
TreeMap<Long, Long> tmap = new TreeMap<>();
long res = 0;
while (t-- > 0) {
res = 0;
int n = in.nextInt();
long m = in.nextLong();
tmap.clear();
long[] arr = new long[n];
res = in.nextLong();
arr[0] = res % m;
res = Long.MIN_VALUE;
tmap.put(arr[0], arr[0]);
for (int i = 1; i < arr.length; i++) {
arr[i] = in.nextLong();
arr[i] %= m;
arr[i] += arr[i - 1];
arr[i] %= m;
if (tmap.higherEntry(arr[i]) == null) {
res = Math.max(res, arr[i]);
tmap.put(arr[i], arr[i]);
continue;
}
long val = tmap.higherEntry(arr[i]).getValue();
res = Math.max(res, (arr[i] - val + m) % m);
tmap.put(arr[i], arr[i]);
}
System.out.println(res);
}
}
/**
* Reads image meta data.
*
* @param oimage
* @return
*/
public static Map<String, String> readImageData(IIOImage oimage) {
Map<String, String> dict = new HashMap<String, String>();
IIOMetadata imageMetadata = oimage.getMetadata();
if (imageMetadata != null) {
IIOMetadataNode dimNode = (IIOMetadataNode) imageMetadata.getAsTree("javax_imageio_1.0");
NodeList nodes = dimNode.getElementsByTagName("HorizontalPixelSize");
int dpiX;
if (nodes.getLength() > 0) {
float dpcWidth = Float.parseFloat(nodes.item(0).getAttributes().item(0).getNodeValue());
dpiX = (int) Math.round(25.4f / dpcWidth);
} else {
dpiX = Toolkit.getDefaultToolkit().getScreenResolution();
}
dict.put("dpiX", String.valueOf(dpiX));
nodes = dimNode.getElementsByTagName("VerticalPixelSize");
int dpiY;
if (nodes.getLength() > 0) {
float dpcHeight = Float.parseFloat(nodes.item(0).getAttributes().item(0).getNodeValue());
dpiY = (int) Math.round(25.4f / dpcHeight);
} else {
dpiY = Toolkit.getDefaultToolkit().getScreenResolution();
}
dict.put("dpiY", String.valueOf(dpiY));
}
return dict;
}
public static void main(String[] args) throws IOException {
input.init(System.in);
PrintWriter out = new PrintWriter(System.out);
int depth = input.nextInt();
int n = (1 << (depth + 1));
int[] as = new int[n];
for (int i = 2; i < n; i++) as[i] = input.nextInt();
int[] paths = new int[n];
int max = 0;
ArrayList<Integer>[] under = new ArrayList[n];
for (int i = 0; i < n; i++) under[i] = new ArrayList<Integer>();
for (int i = (1 << (depth)); i < n; i++) {
int cur = i;
while (cur > 1) {
under[cur].add(i);
paths[i] += as[cur];
cur /= 2;
}
max = Math.max(max, paths[i]);
}
int res = 0;
for (int i = 2; i < n; i++) {
int cm = 0;
for (int x : under[i]) cm = Math.max(cm, paths[x]);
int diff = max - cm;
res += diff;
for (int x : under[i]) paths[x] += diff;
}
out.println(res);
out.close();
}
private void doesEatRegime() {
if (isEnd) return;
if (Math.abs(blocks.peekFirst().getX() - regimeRectangle.getX()) < 10
&& Math.abs(blocks.peekFirst().getY() - regimeRectangle.getY()) < 10
&& System.currentTimeMillis() - currentTime <= 10000) {
regimeRectangle.setX(1200);
isRegime = false;
++score;
scoreLabel.setText(String.valueOf(score));
blocks.pollLast();
blocks.pollLast();
blocks.pollLast();
group.getChildren().remove(rectangles.peekLast());
rectangles.pollLast();
group.getChildren().remove(rectangles.peekLast());
rectangles.pollLast();
group.getChildren().remove(rectangles.peekLast());
rectangles.pollLast();
}
if (System.currentTimeMillis() - currentTime > 10000) {
regimeRectangle.setX(1200);
isRegime = false;
}
}
public int[] solve(String[] edgeStrings) {
ArrayList<Integer> oddPoints = new ArrayList<Integer>();
int min = Integer.MAX_VALUE;
for (String s : edgeStrings) {
StringTokenizer st = new StringTokenizer(s);
int from = Integer.parseInt(st.nextToken());
int to = Integer.parseInt(st.nextToken());
edges.add(new Edge(from, to));
min = Math.min(min, from);
min = Math.min(min, to);
oddPoint(oddPoints, from);
oddPoint(oddPoints, to);
}
assert (oddPoints.size() < 3);
if (oddPoints.size() > 0) {
dfs(min(oddPoints));
return toArray(circuit);
} else {
dfs(min);
return toArray(circuit);
}
}
private void addRegime() {
if (isEnd) return;
if (feedCounter2 - feedCounter1 != 4 || isRegime || feedCounter2 == 0) return;
feedCounter1 = feedCounter2;
currentTime = System.currentTimeMillis();
regimeX = Math.abs(random.nextInt()) % 400 + 10;
regimeY = Math.abs(random.nextInt()) % 400 + 10;
List<Block> blockTemp = new ArrayList<>(blocks);
for (int i = 0; i < blockTemp.size(); i++)
if (blockTemp.get(i).getX() < regimeX
&& blockTemp.get(i).getY() < regimeY
&& blockTemp.get(i).getX() + 10 > regimeX
&& blockTemp.get(i).getY() + 10 > regimeY) {
regimeX = Math.abs(random.nextInt()) % 400 + 10;
regimeY = Math.abs(random.nextInt()) % 400 + 10;
}
regimeRectangle.setX(regimeX);
regimeRectangle.setY(regimeY);
isRegime = true;
}
// Give the string and horizontal and verical offsets so that the label is
// drawn in the center.
public void drawLabel(Graphics g, String label, int hoffset, int voffset) {
g.setColor(Color.black);
int pixelsPerNm = DrawPanel.PIXELS_PER_NM;
int xint = (int) Math.round(pixelsPerNm * z);
int yint = (int) Math.round(pixelsPerNm * y);
g.drawString(label, xint - hoffset, yint + voffset);
}
private void addFeed() {
if (isEnd) return;
if (isFeed) return;
feedX = Math.abs(random.nextInt()) % 400 + 10;
feedY = Math.abs(random.nextInt()) % 400 + 60;
List<Block> blockTemp = new ArrayList<>(blocks);
for (int i = 0; i < blockTemp.size(); i++)
if (blockTemp.get(i).getX() < feedX
&& blockTemp.get(i).getY() < feedY
&& blockTemp.get(i).getX() + 10 > feedX
&& blockTemp.get(i).getY() + 10 > feedY) {
feedX = Math.abs(random.nextInt()) % 400 + 10;
feedY = Math.abs(random.nextInt()) % 400 + 60;
}
feedRectangle.setX(feedX);
feedRectangle.setY(feedY);
isFeed = true;
addObstacle();
}
/**
* Write the given text string in the current font, centered on (x, y) and rotated by the
* specified number of degrees
*
* @param x the center x-coordinate of the text
* @param y the center y-coordinate of the text
* @param s the text
* @param degrees is the number of degrees to rotate counterclockwise
*/
public static void text(double x, double y, String s, double degrees) {
double xs = scaleX(x);
double ys = scaleY(y);
offscreen.rotate(Math.toRadians(-degrees), xs, ys);
text(x, y, s);
offscreen.rotate(Math.toRadians(+degrees), xs, ys);
}
public double getHu2(int region) {
double eta20 = this.getEta(region, 2, 0);
double eta02 = this.getEta(region, 0, 2);
double eta11 = this.getEta(region, 1, 1);
return Math.pow(eta20 - eta02, 2) + Math.pow(2 * eta11, 2);
}
private ArrayList<Double> forwardProp(Double[] input) {
for (int i = 0; i < hiddenLNo; i++) {
for (int j = 0; j < inputSize + 1; j++) {
if (j == inputSize) {
hiddenNodes.set(i, hiddenNodes.get(i) + w1[j][i] * bias);
} else {
hiddenNodes.set(i, hiddenNodes.get(i) + w1[j][i] * input[j]);
}
}
double temp = (1.0 / (1.0 + Math.exp(-hiddenNodes.get(i))));
hiddenNodes.set(i, temp);
}
for (int i = 0; i < outputLNo; i++) {
for (int j = 0; j < hiddenLNo + 1; j++) {
if (j == hiddenNodes.size()) {
outputNodes.set(i, outputNodes.get(i) + w2[j][i] * bias);
} else {
outputNodes.set(i, outputNodes.get(i) + w2[j][i] * hiddenNodes.get(j));
}
}
// double temp1 = (1.0 / (1.0 + Math.exp(-outputNodes.get(i))));
outputNodes.set(i, (1.0 / (1.0 + Math.exp(-outputNodes.get(i)))));
}
return outputNodes;
}
// if left is true --> left is the anchoring End(IS element-known)
// --> then the right side is the insertion position so we check the rightside.
public boolean isInsertionPair(Record other, boolean left) {
if (left) {
// --this--><--other--
if (this.fwd2 && !other.fwd2) {
if ((this.start2 < other.start2)
&& (other.end2 > this.end2)
&& (Math.abs(this.end2 - other.start2) <= 100)) return true;
}
// --other--><--this--
else if (other.fwd2 && !this.fwd2) {
if ((other.start2 < this.start2)
&& (this.end2 > other.end2)
&& (Math.abs(other.end2 - this.start2) <= 100)) return true;
}
} else {
// --this--><--other--
if (this.fwd1 && !other.fwd1) {
if ((this.start1 < other.start1)
&& (other.end1 > this.end1)
&& (Math.abs(this.end1 - other.start1) <= 100)) return true;
}
// --other--><--this--
else if (other.fwd1 && !this.fwd1) {
if ((other.start1 < this.start1)
&& (this.end1 > other.end1)
&& (Math.abs(other.end1 - this.start1) <= 100)) return true;
}
}
return false;
}
public static void testTargetFeaturesAgainstImages(
Vector<HaarFeature> features, Vector<IntegralImage> images) {
int numberOfTrue = 0;
int numberOfFalse = 0;
for (IntegralImage ii : images) {
float weightSum = 0.0f;
float sum = 0.0f;
for (HaarFeature hf : features) {
// HaarFeature hf = allFeatures.get(slimFeature.featureNumber);
// hf.threshold = slimFeature.threshold;
float v = hf.weight * ii.evaluateAsClassifier(hf);
sum += v;
weightSum += hf.weight;
}
boolean success = (sum >= weightSum * 0.5f);
// System.out.println("image " + ii.name + " is a " + success + " : " + sum + " > " +
// weightSum*0.5f);
if (success) {
numberOfTrue++;
} else {
numberOfFalse++;
}
}
System.out.println("*************");
System.out.println("true: " + numberOfTrue);
System.out.println("false: " + numberOfFalse);
int min = Math.min(numberOfFalse, numberOfTrue);
int max = Math.max(numberOfFalse, numberOfTrue);
float percentError = min * 100.0f / max;
System.out.println("percentError = " + percentError);
}
/**
* Read bytes into a portion of an array. This method will block until some input is available,
* an I/O error occurs, or the end of the stream is reached.
*
* @param cbuf Destination buffer.
* @param off Offset at which to start storing bytes.
* @param len Maximum number of bytes to read.
* @return The number of bytes read, or -1 if the end of the stream has been reached
* @throws IOException if the stream is closed.
* @since ostermillerutils 1.00.00
*/
@Override
public int read(byte[] cbuf, int off, int len) throws IOException {
while (true) {
synchronized (CircularByteBuffer.this) {
if (inputStreamClosed)
throw new IOException(
"InputStream has been closed; cannot read from a closed InputStream.");
int available = CircularByteBuffer.this.available();
if (available > 0) {
int length = Math.min(len, available);
int firstLen = Math.min(length, buffer.length - readPosition);
int secondLen = length - firstLen;
System.arraycopy(buffer, readPosition, cbuf, off, firstLen);
if (secondLen > 0) {
System.arraycopy(buffer, 0, cbuf, off + firstLen, secondLen);
readPosition = secondLen;
} else {
readPosition += length;
}
if (readPosition == buffer.length) {
readPosition = 0;
}
ensureMark();
return length;
} else if (outputStreamClosed) {
return -1;
}
}
try {
Thread.sleep(100);
} catch (Exception x) {
throw new IOException("Blocking read operation interrupted.");
}
}
}
