    value = value.setScale(2, RoundingMode.CEILING)

    UPDATE dbo.TestStudents  
    SET LASTNAME = 
    ( CASE  
    WHEN (LASTNAME = &#39;AAA&#39;) THEN &#39;BBB&#39; 
    WHEN (LASTNAME = &#39;CCC&#39;) THEN &#39;DDD&#39; 
    WHEN (LASTNAME = &#39;EEE&#39;) THEN &#39;FFF&#39; 
    ELSE  (LASTNAME)
    END )
The statement work for the purpose but the else condition scan through every record in the table. Is there any way I can leave the unaffected rows as they are?


I want to use CASE statement to update some records in sql server 2005

I have a situation with some code where `eval()` came up as a possible solution.  Now I have never had to use `eval()` before but, I have come across plenty of information about the potential danger it can cause.  That said, I&#39;m very wary about using it.

My situation is that I have input being given by a user:

    datamap = input(&#39;Provide some data here: &#39;)

Where `datamap` needs to be a dictionary.  I searched around and found that `eval()` could work this out. I thought that I might be able to check the type of the input before trying to use the data and that would be a viable security precaution.

    datamap = eval(input(&#39;Provide some data here: &#39;)
    if not isinstance(datamap, dict):
        return

I read through the docs and I am still unclear if this would be safe or not.  Does eval evaluate the data as soon as its entered or after the `datamap` variable is called?

Is the `ast` module&#39;s `.literal_eval()` the only safe option?


Using python&#39;s eval() vs. ast.literal_eval()

I&#39;m trying to round BigDecimal values up, to two decimal places.

I&#39;m using

    BigDecimal rounded = value.round(new MathContext(2, RoundingMode.CEILING));
    logger.trace(&quot;rounded {} to {}&quot;, value, rounded);

but it doesn&#39;t do what I want consistently:

    rounded 0.819 to 0.82
    rounded 1.092 to 1.1
    rounded 1.365 to 1.4 // should be 1.37
    rounded 2.730 to 2.8 // should be 2.74
    rounded 0.819 to 0.82

I don&#39;t care about significant digits, I just want two decimal places. How do I do this with BigDecimal? Or is there another class/library better suited to this?

Rounding BigDecimal to *always* have two decimal places

I'm trying to round BigDecimal values up, to two decimal places.
I'm using
<pre><code class="hljs language-ini">BigDecimal rounded = value.round(new MathContext(2, RoundingMode.CEILING));
logger.trace("rounded {} to {}", value, rounded);
</code></pre>
but it doesn't do what I want consistently:
<pre><code class="hljs language-css">rounded 0.819 to 0.82
rounded 1.092 to 1.1
rounded 1.365 to 1.4 // should be 1.37
rounded 2.730 to 2.8 // should be 2.74
rounded 0.819 to 0.82
</code></pre>
I don't care about significant digits, I just want two decimal places. How do I do this with BigDecimal? Or is there another class/library better suited to this?

I just began to learn Java.

My friend who is helping me study just sent me this and said &#39;figure this out&#39;.

Unfortunately I am unable to read this. It looks like Perl to me. 

    class _{_ _;_(){_=this;}}

What does it mean?

What is the underscore actually doing in this Java code?

In Java we use `final` keyword with variables to specify its values are not to be changed.
But I see that you can change the value in the constructor / methods of the class. Again, if the variable is `static` then it is a compilation error.

Here is the code: 
    
    import java.util.ArrayList;
    import java.util.List;

    class Test {
      private final List foo;
    	
      public Test()
      {
    	  foo = new ArrayList();
    	  foo.add(&quot;foo&quot;); // Modification-1
      }
      public static void main(String[] args) 
      {
    	  Test t = new Test();
    	  t.foo.add(&quot;bar&quot;); // Modification-2
    	  System.out.println(&quot;print - &quot; + t.foo);
      }
    }
Above code works fine and no errors.

Now change the variable as `static`:

    private static final List foo;

Now it is a compilation error. How does this `final` really work?

How does the &quot;final&quot; keyword in Java work? (I can still modify an object.)

If you have an monitor with a DPI over 150 (such as Macbook Pro), you may also find the problem: ***the font on the Java Swing app is too small for high DPI monitor***, and I cannot change the font size at all ( It ignores the Windows DPI directly, only displaying ***the very original DPI--&gt;96*** ). I can do nothing but changing the screen resolution, which could absolutely make everything blurry on LCD.

Yes, I have a laptop with a high DPI monitor, 15.6&#39; with 1920x1080 resolution, some Java desktop apps look very small on my laptop, such as Matlab, Burpsuite etc. I have been searching the Internet for a very very long time, but still cannot find a method for the problem. I know I can change the JRE fonts through `JRE_HOME/lib/font/fontconfig.properties.src`, but I cannot find any place to set the default font size or DPI for Java desktop fonts. 

Does the problem have no solution? Do you have a high DPI monitor? How do you do with such apps? Does Swing give up high DPI users?

How to set the DPI of Java Swing apps on Windows/Linux?

I am using Spring AOP and have below aspect:

    @Aspect
    public class LoggingAspect {
     
    	@Before(&quot;execution(* com.mkyong.customer.bo.CustomerBo.addCustomer(..))&quot;)
    	public void logBefore(JoinPoint joinPoint) {
     
    		System.out.println(&quot;logBefore() is running!&quot;);
    		System.out.println(&quot;hijacked : &quot; + joinPoint.getSignature().getName());
    		System.out.println(&quot;******&quot;);
    	}
     
    }

Above aspect intercepts `addCustomer` method execution. `addCustomer` method takes string as an input. 
But I need to log input passed to `addCustomer` method inside `logBefore` method.&lt;br&gt;
Is it possible to do so ?


Get method arguments using Spring AOP?

The queryforInt/queryforLong methods in JdbcTemplate are deprecated in Spring 3.2. I can&#39;t find out why or what is considered the best practice to replace existing code using these methods.

A typical method:

    int rowCount = jscoreJdbcTemplate.queryForInt(
        &quot;SELECT count(*) FROM _player WHERE nameKey = ? AND teamClub = ?&quot;,
        playerNameKey.toUpperCase(),
		teamNameKey.toUpperCase()
    );


OK the above method needs to be re-written as follows:

    Object[] params = new Object[] { 
       playerNameKey.toUpperCase(), 
       teamNameKey.toUpperCase()
    };
    int rowCount = jscoreJdbcTemplate.queryForObject(
        &quot;SELECT count(*) FROM _player WHERE nameKey = ? AND teamClub = ?&quot;,
        params, Integer.class);


Obviously this deprecation makes the JdbcTemplate class simpler (or does it?). QueryForInt was always a convenience method (I guess) and has been around a long time. Why has it been removed. The code becomes more complicated as a result.

JdbcTemplate queryForInt/Long is deprecated in Spring 3.2.2. What should it be replaced by?

When casting a NumPy Not-a-Number value as a boolean, it becomes True, e.g. as follows.

    &gt;&gt;&gt; import numpy as np
    &gt;&gt;&gt; bool(np.nan)
    True

This is the exact opposite to what I would intuitively expect. Is there a sound principle underlying this behaviour?

(I suspect there might be as the same behaviour seems to occur in Octave.)

Why do &quot;Not a Number&quot; values equal True when cast as boolean in Python/Numpy?

I want to be able to get a estimate of the distance between two (latitude, longitude) points. I want to undershoot, as this will be for A* graph search and I want it to be **fast**. The points will be at most 800 km apart.

How can I quickly estimate the distance between two (latitude, longitude) points?

I have the following JavaScript syntax:

    var discount = Math.round(100 - (price / listprice) * 100);

This rounds up to the whole number. How can I return the result with two decimal places?


JavaScript math, round to two decimal places

Just starting out with Python, so this is probably my mistake, but...

I&#39;m trying out Python. I like to use it as a calculator, and I&#39;m slowly working through some tutorials.

I ran into something weird today. I wanted to find out 2013*2013, but I wrote the wrong thing and wrote 2013*013, and got this:

    &gt;&gt;&gt; 2013*013
    22143

I checked with my calculator, and 22143 is the wrong answer! 2013 * 13 is supposed to be 26169.

Why is Python giving me a wrong answer? My old Casio calculator doesn&#39;t do this...


Wrong math with Python?

I&#39;m dealing with currencies and I want to round down the number to 2 decimal places. Even if the number is 500.0, I would like it to be 500.00 to be consistent. When I do &quot;500.00&quot;.to_d it converts it to 500.0.


Whats a good way of changing this behavior? I also use this method to round down to 2 digits and make sure it always has 2 decimals. 

    def self.round_down(x, n=2)
    	s = x.to_s  	
  		l = s.index(&#39;.&#39;) ? s.index(&#39;.&#39;) + 1 + n : s.length
  		s = s[0, l]
  		s =  s.index(&#39;.&#39;) ? s.length - (s.index(&#39;.&#39;) + 1) == 1 ? s &lt;&lt; &#39;0&#39; : s : s &lt;&lt; &#39;.00&#39;    	
  		s.to_f
  	end

to_d to always return 2 decimals places in ruby

I am looking for the best way to convert a Number to a BigDecimal.

Is this good enough?

    Number number;
    BigDecimal big = new BigDecimal(number.toString());

Can we lose precision with the `toString()` method ?

Convert Java Number to BigDecimal : best way

I need to remove trailing zeros from `BigDecimal` along with `RoundingMode.HALF_UP`. For instance,

    Value        Output
    
    15.3456  &lt;=&gt; 15.35
    15.999   &lt;=&gt; 16            //No trailing zeros.
    15.99    &lt;=&gt; 15.99
    15.0051  &lt;=&gt; 15.01
    15.0001  &lt;=&gt; 15           //No trailing zeros.
    15.000000&lt;=&gt; 15           //No trailing zeros.
    15.00    &lt;=&gt; 15           //No trailing zeros.

[`stripTrailingZeros()`][1] works but it returns scientific notations in situations like,

    new BigDecimal(&quot;600.0&quot;).setScale(2, RoundingMode.HALF_UP).stripTrailingZeros();

In this case, it returns `6E+2`. I need this in a custom converter in JSF where it might be ugly for end users. So, what is the proper way of doing this?


  [1]: https://docs.oracle.com/javase/8/docs/api/java/math/BigDecimal.html#stripTrailingZeros--

Removing trailing zeros from BigDecimal in Java

I have this String: 10,692,467,440,017.120 (it&#39;s an amount).

I want to parse it to a BigDecimal. The problem is that I have tried both DecimalFormat and NumbeFormat in vain.

How can I parse a String to BigDecimal?

I want a function to convert *Bigdecimal* `10.12 for 10.12345` and `10.13 for 10.12556`.
But no function is satisfying both conversion in same time.Please help to achieve this.

Below is what I tried.&lt;br&gt;
With value 10.12345:

    BigDecimal a = new BigDecimal(&quot;10.12345&quot;);
    
    a.setScale(2, BigDecimal.ROUND_UP)
    a.setScale(2, BigDecimal.ROUND_CEILING)
    a.setScale(2, BigDecimal.ROUND_DOWN)
    a.setScale(2, BigDecimal.ROUND_FLOOR)
    a.setScale(2, BigDecimal.ROUND_HALF_DOWN)
    a.setScale(2, BigDecimal.ROUND_HALF_EVEN)
    a.setScale(2, BigDecimal.ROUND_HALF_UP)

Output :

    10.12345::10.13
    10.12345::10.13
    10.12345::10.12
    10.12345::10.12
    10.12345::10.12
    10.12345::10.12
    10.12345::10.12
With value 10.12556:

    BigDecimal b = new BigDecimal(&quot;10.12556&quot;);
    
    b.setScale(2, BigDecimal.ROUND_UP)
    b.setScale(2, BigDecimal.ROUND_CEILING)
    b.setScale(2, BigDecimal.ROUND_DOWN)
    b.setScale(2, BigDecimal.ROUND_FLOOR)
    b.setScale(2, BigDecimal.ROUND_HALF_DOWN)
    b.setScale(2, BigDecimal.ROUND_HALF_EVEN)
    b.setScale(2, BigDecimal.ROUND_HALF_UP)

Output :

    10.12556::10.13
    10.12556::10.13
    10.12556::10.12
    10.12556::10.12
    10.12556::10.12
    10.12556::10.12
    10.12556::10.12




Rounding Bigdecimal values with 2 Decimal Places

I have a collection of BigDecimals (in this example, a `LinkedList`) that I would like to add together. Is it possible to use streams for this?

I noticed the `Stream` class has several methods

    Stream::mapToInt
    Stream::mapToDouble
    Stream::mapToLong

Each of which has a convenient `sum()` method. But, as we know, `float` and `double` arithmetic is almost always a bad idea.

So, is there a convenient way to sum up BigDecimals?

This is the code I have so far.

    public static void main(String[] args) {
        LinkedList&lt;BigDecimal&gt; values = new LinkedList&lt;&gt;();
        values.add(BigDecimal.valueOf(.1));
        values.add(BigDecimal.valueOf(1.1));
        values.add(BigDecimal.valueOf(2.1));
        values.add(BigDecimal.valueOf(.1));
        
        // Classical Java approach
        BigDecimal sum = BigDecimal.ZERO;
        for(BigDecimal value : values) {
            System.out.println(value);
            sum = sum.add(value);
        }
        System.out.println(&quot;Sum = &quot; + sum);
        
        // Java 8 approach
        values.forEach((value) -&gt; System.out.println(value));
        System.out.println(&quot;Sum = &quot; + values.stream().mapToDouble(BigDecimal::doubleValue).sum());
        System.out.println(values.stream().mapToDouble(BigDecimal::doubleValue).summaryStatistics().toString());
    }

As you can see, I am summing up the BigDecimals using `BigDecimal::doubleValue()`, but this is (as expected) not precise.


**Post-answer edit for posterity:**

Both answers were extremely helpful. I wanted to add a little: my real-life scenario does not involve a collection of raw `BigDecimal`s, they are wrapped in an invoice. But, I was able to modify Aman Agnihotri&#39;s answer to account for this by using the `map()` function for stream:

    public static void main(String[] args) {
        
        LinkedList&lt;Invoice&gt; invoices = new LinkedList&lt;&gt;();
        invoices.add(new Invoice(&quot;C1&quot;, &quot;I-001&quot;, BigDecimal.valueOf(.1), BigDecimal.valueOf(10)));
        invoices.add(new Invoice(&quot;C2&quot;, &quot;I-002&quot;, BigDecimal.valueOf(.7), BigDecimal.valueOf(13)));
        invoices.add(new Invoice(&quot;C3&quot;, &quot;I-003&quot;, BigDecimal.valueOf(2.3), BigDecimal.valueOf(8)));
        invoices.add(new Invoice(&quot;C4&quot;, &quot;I-004&quot;, BigDecimal.valueOf(1.2), BigDecimal.valueOf(7)));
        
        // Classical Java approach
        BigDecimal sum = BigDecimal.ZERO;
        for(Invoice invoice : invoices) {
            BigDecimal total = invoice.unit_price.multiply(invoice.quantity);
            System.out.println(total);
            sum = sum.add(total);
        }
        System.out.println(&quot;Sum = &quot; + sum);
        
        // Java 8 approach
        invoices.forEach((invoice) -&gt; System.out.println(invoice.total()));
        System.out.println(&quot;Sum = &quot; + invoices.stream().map((x) -&gt; x.total()).reduce((x, y) -&gt; x.add(y)).get());
    }
    
    static class Invoice {
        String company;
        String invoice_number;
        BigDecimal unit_price;
        BigDecimal quantity;

        public Invoice() {
            unit_price = BigDecimal.ZERO;
            quantity = BigDecimal.ZERO;
        }

        public Invoice(String company, String invoice_number, BigDecimal unit_price, BigDecimal quantity) {
            this.company = company;
            this.invoice_number = invoice_number;
            this.unit_price = unit_price;
            this.quantity = quantity;
        }
        
        public BigDecimal total() {
            return unit_price.multiply(quantity);
        }

        public void setUnit_price(BigDecimal unit_price) {
            this.unit_price = unit_price;
        }

        public void setQuantity(BigDecimal quantity) {
            this.quantity = quantity;
        }

        public void setInvoice_number(String invoice_number) {
            this.invoice_number = invoice_number;
        }

        public void setCompany(String company) {
            this.company = company;
        }

        public BigDecimal getUnit_price() {
            return unit_price;
        }

        public BigDecimal getQuantity() {
            return quantity;
        }

        public String getInvoice_number() {
            return invoice_number;
        }

        public String getCompany() {
            return company;
        }
    }

Adding up BigDecimals using Streams

I want to take a floating-point number and round it down to the nearest integer. However, if it&#39;s not a whole, I *always* want to round down the variable, regardless of how close it is to the next integer up. Is there a way to do this?

Round a floating-point number down to the nearest integer?

Using Python 2.7 how do I round my numbers to two decimal places rather than the 10 or so it gives?

    print &quot;financial return of outcome 1 =&quot;,&quot;$&quot;+str(out1)

Rounding to two decimal places in Python 2.7?

I need a utility function that takes in an integer value (ranging from 2 to 5 digits in length) that rounds up to the **next** multiple of 5 instead of the **nearest** multiple of 5. Here is what I got:

    function round5(x)
    {
        return (x % 5) &gt;= 2.5 ? parseInt(x / 5) * 5 + 5 : parseInt(x / 5) * 5;
    }

When I run `round5(32)`, it gives me `30`, where I want 35.  
When I run `round5(37)`, it gives me `35`, where I want 40.  

When I run `round5(132)`, it gives me `130`, where I want 135.  
When I run `round5(137)`, it gives me `135`, where I want 140.  

etc...

How do I do this?

Javascript: Round up to the next multiple of 5

Let:

    double d = 0.1;
    float f = 0.1;

should the expression

    (f &gt; d)

return `true` or `false`?

Empirically, the answer is `true`. However, I expected it to be `false`.  

As `0.1` cannot be perfectly represented in binary, while double has `15` to `16` decimal digits of precision, and float has only `7`. So, they both are less than `0.1`, while the double is more close to `0.1`.

I need an exact explanation for the `true`.

0.1 float is greater than 0.1 double. I expected it to be false

I am getting a lot of decimals in the output of this code (Fahrenheit to Celsius converter).

My code currently looks like this:

    def main():
        printC(formeln(typeHere()))
        
    def typeHere():
        global Fahrenheit
        try:
            Fahrenheit = int(raw_input(&quot;Hi! Enter Fahrenheit value, and get it in Celsius!\n&quot;))
        except ValueError:
            print &quot;\nYour insertion was not a digit!&quot;
            print &quot;We&#39;ve put your Fahrenheit value to 50!&quot;
            Fahrenheit = 50
        return Fahrenheit
        
    def formeln(c):
        Celsius = (Fahrenheit - 32.00) * 5.00/9.00
        return Celsius
        
    def printC(answer):
        answer = str(answer)
        print &quot;\nYour Celsius value is &quot; + answer + &quot; C.\n&quot;
    
    
        
    main()

So my question is, how do I make the program round every answer to the 2nd decimal place?

Content Type	Original Author	Original Content on Stackoverflow
Question	Brad Mace	View Question on Stackoverflow
Solution 1 - Java	Louis Wasserman	View Answer on Stackoverflow

Rounding BigDecimal to always have two decimal places

Java Problem Overview

Java Solutions

Solution 1 - Java

Using python's eval() vs. ast.literal_eval()

I want to use CASE statement to update some records in sql server 2005

Attributions