Ejemplo n.º 1
1
 public int minimumPrice(long[] dread, int[] price) {
   int n = dread.length;
   int m = n << 1;
   long[] maximum = new long[m + 1];
   Arrays.fill(maximum, 0);
   for (int i = 0; i < n; ++i) {
     long[] new_maximum = new long[m + 1];
     Arrays.fill(new_maximum, -1);
     for (int j = 0; j <= m; ++j) {
       if (maximum[j] != -1) {
         if (maximum[j] >= dread[i]) {
           new_maximum[j] = Math.max(new_maximum[j], maximum[j]);
         }
         if (j + price[i] <= m) {
           new_maximum[j + price[i]] = Math.max(new_maximum[j + price[i]], maximum[j] + dread[i]);
         }
       }
     }
     maximum = new_maximum;
   }
   int answer = 0;
   while (maximum[answer] == -1) {
     answer++;
   }
   return answer;
 }
Ejemplo n.º 2
0
 public int count(
     String[] s1000,
     String[] s100,
     String[] s10,
     String[] s1,
     String[] t1000,
     String[] t100,
     String[] t10,
     String[] t1) {
   String S1000 = concate(s1000);
   String S100 = concate(s100);
   String S10 = concate(s10);
   String S1 = concate(s1);
   String T1000 = concate(t1000);
   String T100 = concate(t100);
   String T10 = concate(t10);
   String T1 = concate(t1);
   int n = S1000.length();
   Interval[] intervals = new Interval[n];
   for (int i = 0; i < n; ++i) {
     intervals[i] =
         new Interval(
             Integer.parseInt(
                 S1000.substring(i, i + 1) + S100.charAt(i) + S10.charAt(i) + S1.charAt(i)),
             Integer.parseInt(
                 T1000.substring(i, i + 1) + T100.charAt(i) + T10.charAt(i) + T1.charAt(i)));
   }
   Arrays.sort(intervals);
   int leftmost = Integer.MAX_VALUE;
   int rightmost = Integer.MIN_VALUE;
   for (int i = 0; i < n; ++i) {
     leftmost = Math.min(leftmost, intervals[i].b);
     rightmost = Math.max(rightmost, intervals[i].a);
   }
   int answer = 0;
   for (int i = 0; i < n; ++i) {
     int total = 0;
     int now = leftmost;
     int j = 0;
     while (true) {
       if (intervals[i].a <= now) {
         now = Math.max(now, intervals[i].b);
       }
       if (now >= rightmost) {
         break;
       }
       int best = now;
       while (j < n && intervals[j].a <= now) {
         best = Math.max(best, intervals[j++].b);
       }
       if (best <= now) {
         return -1;
       }
       total++;
       now = best;
     }
     answer += total;
   }
   return answer;
 }
Ejemplo n.º 3
0
  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();
  }
Ejemplo n.º 4
0
  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);
    }
  }
Ejemplo n.º 5
0
 /**
  * Returns the date in seconds.
  *
  * @return seconds
  */
 final BigDecimal seconds() {
   int z = tz;
   if (z == Short.MAX_VALUE) {
     // [CG] XQuery, DateTime: may be removed
     final long n = System.currentTimeMillis();
     z = Calendar.getInstance().getTimeZone().getOffset(n) / 60000;
   }
   return (sec == null ? BigDecimal.ZERO : sec)
       .add(BigDecimal.valueOf(Math.max(0, hou) * 3600 + Math.max(0, min) * 60 - z * 60));
 }
 public static void main(String[] args) {
   Scanner inp = new Scanner(System.in);
   int n = inp.nextInt();
   String[] store = new String[n];
   for (int i = 0; i < n; i++) store[i] = inp.next();
   int[] cnt = new int[n];
   Arrays.fill(cnt, 0);
   String str = inp.next();
   for (int j = 0; j < n; j++) {
     int l1 = store[j].length();
     for (int k = 0; k <= (str.length() - l1); k++) {
       if (str.substring(k, k + l1).equals(store[j])) {
         cnt[j] = cnt[j] + 1;
       }
     }
   }
   int y = 0;
   for (int m = 0; m < n; m++) {
     y = Math.max(y, cnt[m]);
   }
   System.out.println(y);
   for (int h = 0; h < n; h++) {
     if (cnt[h] == y) System.out.println(store[h]);
   }
 }
Ejemplo n.º 7
0
  // Constructor::TextContext
  //
  // Generates a TextContext Object.
  //
  // Generates before and after contexts based on given length and values
  //
  // Parameters
  //
  // * primary -- TextPrimary object to be tested against context
  // * constraint -- TextConstraint object attached to this context
  // * checkSumType -- Hash for checksum
  // * contextLength - length (in chars) of the context used for testing
  //
  public TextContext(
      TextPrimary primary, TextConstraint constraint, HashType checkSumType, int contextLength) {
    super();
    this.checkSumType = checkSumType;
    //	Testing if content matches the bit-checksum tests

    this.checkSum = checkSum(primary.getContent(), checkSumType);

    int beforeStart = constraint.getStartPos() - contextLength;
    beforeStart = Math.max(0, beforeStart);
    int beforeEnd = constraint.getStartPos();

    int afterStart = constraint.getEndPos();
    int afterEnd = constraint.getEndPos() + contextLength;
    afterEnd = Math.min(primary.getContent().length(), afterEnd);

    // Evaluating how much of selected text to store
    this.totalSelectionLength = primary.getContent().length();
    int cLength = this.totalSelectionLength;
    if (this.totalSelectionLength > DEFAULT_CONTEXTLENGTH) {
      double half = (double) (this.totalSelectionLength / 2);
      cLength = (int) (Math.floor(half * percentStorage));
      this.beginSel = primary.getContent().substring(beforeEnd, (beforeEnd + cLength));
      this.endSel = primary.getContent().substring((afterStart - cLength), afterStart);
      this.totalSelection = this.beginSel.concat(this.endSel);
    } else {
      // Use the entire selection
      this.beginSel = "";
      this.endSel = "";
      this.totalSelection = primary.getContent();
    }

    this.beforeContext = primary.getContent().substring(beforeStart, beforeEnd);
    this.afterContext = primary.getContent().substring(afterStart, afterEnd);
  }
Ejemplo n.º 8
0
  public static void main(String[] args) throws IOException {
    /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    int n = Integer.parseInt(br.readLine());
    int a[] = new int[n];
    int c[] = new int[n];
    for (int i = 0; i < n; i++) {
      a[i] = Integer.parseInt(br.readLine());
    }

    for (int i = 0; i < n; i++) {
      c[i] = 1;
    }

    for (int j = 1; j < n; j++) {
      if (a[j] > a[j - 1]) c[j] = c[j - 1] + 1;
    }

    for (int k = n - 2; k >= 0; k--) {
      if (a[k] > a[k + 1]) c[k] = Math.max(c[k + 1] + 1, c[k]);
    }
    int count = 0;
    for (int i = 0; i < n; i++) {
      count += c[i];
    }

    System.out.println(count);
  }
Ejemplo n.º 9
0
  public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int arr[][] = new int[6][6];
    int max = -10000; // lowest possible value is -9*6=-54
    int sum;
    for (int arr_i = 0; arr_i < 6; arr_i++) {
      for (int arr_j = 0; arr_j < 6; arr_j++) {
        arr[arr_i][arr_j] = in.nextInt();
      }
    }

    for (int i = 0; i < 4; i++) {
      for (int j = 0; j < 4; j++) {
        sum =
            arr[i][j]
                + arr[i][j + 1]
                + arr[i][j + 2]
                + arr[i + 1][j + 1]
                + arr[i + 2][j]
                + arr[i + 2][j + 1]
                + arr[i + 2][j + 2];
        max = Math.max(sum, max);
      }
    }
    System.out.println(max);
  }
Ejemplo n.º 10
0
  public int solve(int start, int maxV, int be, int[] ivl) {
    if (start < 0 || start > maxV) return -1;
    if (be == ivl.length) return start;

    if (DP[be][start] != -2) return DP[be][start];
    return DP[be][start] =
        Math.max(
            solve(start + ivl[be], maxV, be + 1, ivl), solve(start - ivl[be], maxV, be + 1, ivl));
  }
Ejemplo n.º 11
0
  /**
   * Adds the specified dayTime duration.
   *
   * @param add value to be added
   */
  private void add(final BigDecimal add) {
    // normalized modulo: sc % 60  vs.  (-sc + sc % 60 + 60 + sc) % 60
    final BigDecimal sc = sec().add(add);
    sec =
        sc.signum() >= 0
            ? sc.remainder(BD60)
            : sc.negate().add(sc.remainder(BD60)).add(BD60).add(sc).remainder(BD60);

    final long mn = Math.max(min(), 0) + div(sc.longValue(), 60);
    min = (byte) mod(mn, 60);
    final long ho = Math.max(hou, 0) + div(mn, 60);
    hou = (byte) mod(ho, 24);
    final long da = div(ho, 24);

    final long[] ymd = ymd(days().add(BigDecimal.valueOf(da)));
    yea = ymd[0];
    mon = (byte) ymd[1];
    day = (byte) ymd[2];
  }
Ejemplo n.º 12
0
 public void actionPerformed(ActionEvent e) {
   // Invoked when an action occurs.
   if (e.getSource().equals(singleSizeUp)) {
     singleSize = singleSize * 2;
     singleSizeLabel.setText("Image height=" + singleSize);
   }
   if (e.getSource().equals(singleSizeDown)) {
     singleSize = Math.max(64, singleSize / 2);
     singleSizeLabel.setText("Image height=" + singleSize);
   }
   if (e.getSource().equals(seqSizeUp)) {
     seqSize = seqSize * 2;
     seqSizeLabel.setText("Image height=" + seqSize);
   }
   if (e.getSource().equals(seqSizeDown)) {
     seqSize = Math.max(64, seqSize / 2);
     seqSizeLabel.setText("Image height=" + seqSize);
   }
 }
Ejemplo n.º 13
0
 public static void main(String[] args) {
   while (scan.hasNextDouble()) {
     double t1 = scan.nextDouble();
     double t2 = scan.nextDouble();
     int i1, i2;
     for (i1 = 0; i1 < s1.length; i1++) {
       if (t1 < s1[i1]) break;
     }
     for (i2 = 0; i2 < s2.length; i2++) {
       if (t2 < s2[i2]) break;
     }
     System.out.println(r[Math.max(i1, i2)]);
   }
 }
 // BEGIN KAWIGIEDIT TESTING
 // Generated by KawigiEdit-pf 2.3.0
 private static boolean KawigiEdit_RunTest(
     int testNum, int[] p0, int[] p1, boolean hasAnswer, double p2) {
   System.out.print("Test " + testNum + ": [" + "{");
   for (int i = 0; p0.length > i; ++i) {
     if (i > 0) {
       System.out.print(",");
     }
     System.out.print(p0[i]);
   }
   System.out.print("}" + "," + "{");
   for (int i = 0; p1.length > i; ++i) {
     if (i > 0) {
       System.out.print(",");
     }
     System.out.print(p1[i]);
   }
   System.out.print("}");
   System.out.println("]");
   GreaterGame obj;
   double answer;
   obj = new GreaterGame();
   long startTime = System.currentTimeMillis();
   answer = obj.calc(p0, p1);
   long endTime = System.currentTimeMillis();
   boolean res;
   res = true;
   System.out.println("Time: " + (endTime - startTime) / 1000.0 + " seconds");
   if (hasAnswer) {
     System.out.println("Desired answer:");
     System.out.println("\t" + p2);
   }
   System.out.println("Your answer:");
   System.out.println("\t" + answer);
   if (hasAnswer) {
     res = answer == answer && Math.abs(p2 - answer) <= 1e-9 * Math.max(1.0, Math.abs(p2));
   }
   if (!res) {
     System.out.println("DOESN'T MATCH!!!!");
   } else if ((endTime - startTime) / 1000.0 >= 2) {
     System.out.println("FAIL the timeout");
     res = false;
   } else if (hasAnswer) {
     System.out.println("Match :-)");
   } else {
     System.out.println("OK, but is it right?");
   }
   System.out.println("");
   return res;
 }
Ejemplo n.º 15
0
 void solve() {
   int n = nextInt();
   int m = nextInt();
   int l = 1;
   int r = n;
   for (int i = 0; i < m; i++) {
     nextToken();
     nextToken();
     String s = nextToken();
     nextToken();
     int k = nextInt();
     if (s.equals("left")) {
       r = Math.min(r, k - 1);
     } else {
       l = Math.max(l, k + 1);
     }
   }
   if (l > r) {
     out.println(-1);
   } else {
     out.println(r - l + 1);
   }
 }
Ejemplo n.º 16
0
  public int selectAction() {

    if (currentPath != -1) {
      if (nodePaths[currentPath].contains(currentNode)) {
        currentIndex = nodePaths[currentPath].indexOf(currentNode);
      }
    }
    if (firstStep) {

      pathLength = 0;
      // currentPath=generator.nextInt(paths.length);

      currentPath = selectCycle();
      previousPath = currentPath;
      System.out.println("New path is generated");
      System.out.println(currentPath);
      System.out.println(currentNode);
      firstStep = false;
      if (nodePaths[currentPath].contains(currentNode)) {
        pathLength++;
        currentIndex = nodePaths[currentPath].indexOf(currentNode);
        startTime = System.currentTimeMillis();
        cycleReward =
            cycleReward + payout - travelCost; // currentUtilitiesforVisitingNodes[currentNode];
        return paths[currentPath].get(currentIndex);

      } else {
        cycleReward = 0;

        return 0;
      }
    } else {
      if (currentIndex == 0 && nodePaths[currentPath].contains(currentNode)) {
        currentPath = selectCycle();
        previousPath = currentPath;
        pathLength = 0;

        System.out.println("New path is generated");
        System.out.println(currentPath);
        System.out.println(currentNode);
        firstStep = false;
        if (nodePaths[currentPath].contains(currentNode)) {
          pathLength++;
          currentIndex = nodePaths[currentPath].indexOf(currentNode);
          startTime = System.currentTimeMillis();
          cycleReward =
              cycleReward + payout - travelCost; // currentUtilitiesforVisitingNodes[currentNode];
          return paths[currentPath].get(currentIndex);
        } else {
          cycleReward = 0;
          return 0;
        }
      }
      // if(currentIndex==paths[currentPath].size()-1){

      //	firstStep=true;
      // }
      if (pathLength == paths[currentPath].size() - 1) {
        firstStep = true;
        endTime = System.currentTimeMillis();
        Rtmp = cycleReward * 1000 / (endTime - startTime);
        if (t < N) {
          Rmax = Math.max(Rmax, Rtmp);
        }
        if (t == N) {
          alpha = Rmax;
        }

        if (t > N) {
          alpha = lambda * alpha + (1 - lambda) * Rtmp;
        }
        t = t + 1;
      }
      return paths[currentPath].get(currentIndex);
    }
  }
Ejemplo n.º 17
0
 private int clamp(int val, int min, int max) {
   return Math.max(Math.min(val, max), min);
 }
Ejemplo n.º 18
0
 public String winner(int[] x, int[] y) {
   int n = x.length;
   for (int i = 0; i < n; ++i) {
     x[i] += MAX_ABS;
     y[i] += MAX_ABS;
   }
   ArrayList<Point> points = new ArrayList<Point>();
   int oneCount = 0;
   int twoCount = 0;
   for (int x0 = 0; x0 <= MAX_ABS * 2; ++x0) {
     boolean found = false;
     double yMin = Double.MAX_VALUE;
     double yMax = Double.MIN_VALUE;
     for (int i = 0; i < n; ++i) {
       int x1 = x[i];
       int y1 = y[i];
       int x2 = x[(i + 1) % n];
       int y2 = y[(i + 1) % n];
       if ((long) (x1 - x0) * (x2 - x0) <= 0) {
         found = true;
         if (x1 == x2) {
           yMin = Math.min(yMin, Math.min(y1, y2));
           yMax = Math.max(yMax, Math.max(y1, y2));
         } else {
           double y0 = y1 + (double) (y2 - y1) / (x2 - x1) * (x0 - x1);
           yMin = Math.min(yMin, y0);
           yMax = Math.max(yMax, y0);
         }
       }
     }
     if (found) {
       int count = 0;
       int y0 = (int) Math.ceil(yMin);
       while (count < 2 && y0 <= yMax) {
         boolean valid = true;
         for (int i = 0; i < n; ++i) {
           valid &= x[i] != x0 || y[i] != y0;
         }
         if (valid) {
           count++;
           points.add(new Point(x0, y0));
         }
         y0++;
       }
       if (count >= 1) {
         oneCount++;
       }
       if (count >= 2) {
         twoCount++;
       }
     }
   }
   if (twoCount > 0) {
     return oneCount > 1 ? YES : NO;
   }
   if (points.size() <= 2) {
     return NO;
   }
   Point o = points.get(0);
   for (int i = 2; i < points.size(); ++i) {
     if (points.get(1).subtract(o).det(points.get(i).subtract(o)) != 0) {
       return YES;
     }
   }
   return NO;
 }
Ejemplo n.º 19
0
 /**
  * Returns a day count.
  *
  * @return days
  */
 final BigDecimal days() {
   final long y = yea == Long.MAX_VALUE ? 1 : yea;
   return days(y + ADD_NEG, Math.max(mon, 0), Math.max(day, 0));
 }
Ejemplo n.º 20
0
  /**
   * Analyzes the specified patterns.
   *
   * @param patterns patterns
   * @return picture variables
   */
  private Picture[] analyze(final byte[][] patterns) {
    // pictures
    final int picL = patterns.length;
    final Picture[] pics = new Picture[picL];

    // analyze patterns
    for (int p = 0; p < picL; p++) {
      final byte[] pt = patterns[p];
      final Picture pic = new Picture();

      // position (integer/fractional)
      int pos = 0;
      // active character found
      boolean act = false;
      // number of characters after exponent
      int exp = -1;
      // number of optional characters
      final int[] opt = new int[2];

      // loop through all characters
      final int pl = pt.length;
      for (int i = 0, cl; i < pl; i += cl) {
        final int ch = ch(pt, i);
        cl = cl(pt, i);
        boolean active = contains(actives, ch);

        if (ch == decimal) {
          ++pos;
          act = false;
        } else if (ch == optional) {
          opt[pos]++;
        } else if (ch == exponent) {
          if (act && containsActive(pt, i + cl)) {
            exp = 0;
          } else {
            active = false;
          }
        } else if (ch == grouping) {
          if (pos == 0) pic.group[pos] = Array.add(pic.group[pos], pic.min[pos] + opt[pos]);
        } else if (contains(digits, ch)) {
          if (exp == -1) pic.min[pos]++;
          else exp++;
        }

        if (active) {
          act = true;
        } else {
          // passive characters
          pic.pc |= ch == percent;
          pic.pm |= ch == permille;
          // prefixes/suffixes
          pic.prefSuf[pos == 0 && act ? pos + 1 : pos].add(ch);
        }
      }
      // finalize integer-part-grouping-positions
      final int[] igp = pic.group[0];
      final int igl = igp.length;
      for (int g = 0; g < igl; ++g) igp[g] = pic.min[0] + opt[0] - igp[g];

      // check if integer-part-grouping-positions are regular
      // if yes, they are replaced with a single position
      if (igl > 1) {
        boolean reg = true;
        final int i = igp[igl - 1];
        for (int g = igl - 2; g >= 0; --g) reg &= i * igl == igp[g];
        if (reg) pic.group[0] = new int[] {i};
      }

      pic.maxFrac = pic.min[1] + opt[1];
      pic.minExp = Math.max(0, exp);
      pics[p] = pic;
    }
    return pics;
  }
Ejemplo n.º 21
0
 // To add/remove functions change evaluateOperator() and registration
 public double evaluateFunction(String fncnam, ArgParser fncargs) throws ArithmeticException {
   switch (Character.toLowerCase(fncnam.charAt(0))) {
     case 'a':
       {
         if (fncnam.equalsIgnoreCase("abs")) {
           return Math.abs(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("acos")) {
           return Math.acos(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("asin")) {
           return Math.asin(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("atan")) {
           return Math.atan(fncargs.next());
         }
       }
       break;
     case 'c':
       {
         if (fncnam.equalsIgnoreCase("cbrt")) {
           return Math.cbrt(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("ceil")) {
           return Math.ceil(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("cos")) {
           return Math.cos(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("cosh")) {
           return Math.cosh(fncargs.next());
         }
       }
       break;
     case 'e':
       {
         if (fncnam.equalsIgnoreCase("exp")) {
           return Math.exp(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("expm1")) {
           return Math.expm1(fncargs.next());
         }
       }
       break;
     case 'f':
       {
         if (fncnam.equalsIgnoreCase("floor")) {
           return Math.floor(fncargs.next());
         }
       }
       break;
     case 'g':
       {
         //              if(fncnam.equalsIgnoreCase("getExponent"   )) { return
         // Math.getExponent(fncargs.next());                } needs Java 6
       }
       break;
     case 'l':
       {
         if (fncnam.equalsIgnoreCase("log")) {
           return Math.log(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("log10")) {
           return Math.log10(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("log1p")) {
           return Math.log1p(fncargs.next());
         }
       }
       break;
     case 'm':
       {
         if (fncnam.equalsIgnoreCase("max")) {
           return Math.max(fncargs.next(), fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("min")) {
           return Math.min(fncargs.next(), fncargs.next());
         }
       }
       break;
     case 'n':
       {
         //              if(fncnam.equalsIgnoreCase("nextUp"        )) { return Math.nextUp
         // (fncargs.next());                } needs Java 6
       }
       break;
     case 'r':
       {
         if (fncnam.equalsIgnoreCase("random")) {
           return Math.random();
         } // impure
         if (fncnam.equalsIgnoreCase("round")) {
           return Math.round(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("roundHE")) {
           return Math.rint(fncargs.next());
         } // round half-even
       }
       break;
     case 's':
       {
         if (fncnam.equalsIgnoreCase("signum")) {
           return Math.signum(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("sin")) {
           return Math.sin(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("sinh")) {
           return Math.sinh(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("sqrt")) {
           return Math.sqrt(fncargs.next());
         }
       }
       break;
     case 't':
       {
         if (fncnam.equalsIgnoreCase("tan")) {
           return Math.tan(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("tanh")) {
           return Math.tanh(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("toDegrees")) {
           return Math.toDegrees(fncargs.next());
         }
         if (fncnam.equalsIgnoreCase("toRadians")) {
           return Math.toRadians(fncargs.next());
         }
       }
       break;
     case 'u':
       {
         if (fncnam.equalsIgnoreCase("ulp")) {
           return Math.ulp(fncargs.next());
         }
       }
       break;
       // no default
   }
   throw new UnsupportedOperationException(
       "MathEval internal function setup is incorrect - internal function \""
           + fncnam
           + "\" not handled");
 }