Why are Math Class methods called with 'Math.abs()', but Integer Class methods are called with 'static int sum()' or 'int min()'? I think you are confusing some things here. The examples you show for the integer methods are method definitions. That's not calling a method, it's defining one that returns an int. Doesn't the Math Class have max & min methods? So why does the Integer Class also have max and min methods? The Math.max and Math.min methods have overloads for integers, longs, floats, and doubles. But each of those classes have a specific version of the function that just works on its own. It's likely that the Math class is just "proxying" those other methods, based on what you pass into it. It's just there as a convenience, so you don't have to dip down into four different classes for the same functionality. More on reddit.com

The key thing to note is that BigDecimal is decimal. That is, it stores a precise representation of decimal (base-10) numbers. That is, the number is represented as a sum of powers of ten. float and double are binary (IEEE 754). That is, the number is represented as a sum of powers of two. Thus, when you translate a decimal fraction into a binary fraction, you'll end up with errors, because some decimal fractions cannot be represented exactly as binary fractions (within a given precision). These errors add up. The Math functions are intrinsics. They map directly to native routines, which operate on IEEE 754 floating point numbers. Obviously, most floating point units on processors work on IEEE floats (although, I think some older processors could do BCD math). BigDecimal is implemented purely in Java, trading performance for precision, and any math library operating on BigDecimal would have to reimplement all of those math operations in Java, similarly trading performance for precision, to a greater degree. Whether you choose float of BigDecimal depends on your goals. With money, generally the goal is precision, because of the financial consequences of errors in accounting calculations. But, in scientific and engineering application, the goal is reasonable approximation within an error range. I don't think with Black-Sholes you're looking for precision, but approximation. Thus, it is perfectly fine to use float as long as you arrange your calculations to control the error range. Poor arrangement of floating point calculations can significantly widen the error range, resulting wildly deviating results. For this reason, there are books like Numerical Computing with IEEE Floating Point Arithmetic which show you how to arrange floating point calculations to maintain accuracy within a desired error range. EDITED: I don't write good. More on reddit.com

I always use Random. The reason is that if a class depends on random number generation, it actually has a dependency on another thing whose job it is to generate random numbers (you could even make the argument this is a hidden I/O operation). It's damn near impossible to write a unit test against a class or method that calls a global function because you have no access to mock out the response for that function within a test. This is even more the case for classes that rely on randomly generated numbers. Passing a Random into a class that needs access to random numbers makes it easy to unit-test that class, as well as substitute in alternative RNG as needed, for example using SecureRandom which implements the Random interface, providing a more even distribution of generated numbers at the cost of speed. Random number generators, at least in Java, tend to mutate state internally - which is dangerous for multi-threaded programming. You want to minimize the amount of state mutation in a program to enable multi-threading, and Random turns the mutable state for random number generation to be scoped to an object rather than to the entire global space as Math.random() does. Other benefits of using Random over Math.random(): You can pass a single instance of Random into the first class that needs the ability, and pass the same instance around into lower classes as they require it as well. This means that, on your program runs, if you output the seed number somewhere like into a log or temporary file, you can seed your program with the same seed value and generate exactly the same behavior, deterministically. This makes debugging issues that arise in your program much easier. The Random interface is superior, allowing you to request random booleans, byte sequences, doubles, floats, longs, and ints. It also allows you to request a random int within a specific range. All of these let you avoid inserting the same boilerplate math that uses a Math.random(). More on reddit.com

I think you can probably figure this one out just with a hint.

What happens to negative numbers when they are multiplied by -1?

Note that you can check if numbers are less than zero using if and then do something about less than zero numbers.

If you still get stuck after thinking on that for a few minutes shoot me a pm.

Edit: as long as you don't ask me to just write out all the code for you.

More on reddit.com