PROGRAMMING WITH JAVA

All Sports Streaming: Denver vs Cincinnati Live Streaming

Java math function

java.lang
Class Math

java.lang.Object
  java.lang.Math

public final class Math
extends Object

The class Math contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.
Unlike some of the numeric methods of class StrictMath, all implementations of the equivalent functions of class Math are not defined to return the bit-for-bit same results. This relaxation permits better-performing implementations where strict reproducibility is not required.
By default many of the Math methods simply call the equivalent method in StrictMath for their implementation. Code generators are encouraged to use platform-specific native libraries or microprocessor instructions, where available, to provide higher-performance implementations of Math methods. Such higher-performance implementations still must conform to the specification for Math.
The quality of implementation specifications concern two properties, accuracy of the returned result and monotonicity of the method. Accuracy of the floating-point Math methods is measured in terms of ulps, units in the last place. For a given floating-point format, an ulp of a specific real number value is the difference between the two floating-point values closest to that numerical value. When discussing the accuracy of a method as a whole rather than at a specific argument, the number of ulps cited is for the worst-case error at any argument. If a method always has an error less than 0.5 ulps, the method always returns the floating-point number nearest the exact result; such a method is correctly rounded. A correctly rounded method is generally the best a floating-point approximation can be; however, it is impractical for many floating-point methods to be correctly rounded. Instead, for the Math class, a larger error bound of 1 or 2 ulps is allowed for certain methods. Informally, with a 1 ulp error bound, when the exact result is a representable number the exact result should be returned; otherwise, either of the two floating-point numbers closest to the exact result may be returned. Besides accuracy at individual arguments, maintaining proper relations between the method at different arguments is also important. Therefore, methods with more than 0.5 ulp errors are required to be semi-monotonic: whenever the mathematical function is non-decreasing, so is the floating-point approximation, likewise, whenever the mathematical function is non-increasing, so is the floating-point approximation. Not all approximations that have 1 ulp accuracy will automatically meet the monotonicity requirements.

Field Summary
`static double`	`E` The `double` value that is closer than any other to e, the base of the natural logarithms.
`static double`	`PI` The `double` value that is closer than any other to pi, the ratio of the circumference of a circle to its diameter.

Method Summary
`static double`	`abs(double a)` Returns the absolute value of a `double` value.
`static float`	`abs(float a)` Returns the absolute value of a `float` value.
`static int`	`abs(int a)` Returns the absolute value of an `int` value.
`static long`	`abs(long a)` Returns the absolute value of a `long` value.
`static double`	`acos(double a)` Returns the arc cosine of an angle, in the range of 0.0 through pi.
`static double`	`asin(double a)` Returns the arc sine of an angle, in the range of -pi/2 through pi/2.
`static double`	`atan(double a)` Returns the arc tangent of an angle, in the range of -pi/2 through pi/2.
`static double`	`atan2(double y, double x)` Converts rectangular coordinates (`x`, `y`) to polar (r, theta).
`static double`	`ceil(double a)` Returns the smallest (closest to negative infinity) `double` value that is not less than the argument and is equal to a mathematical integer.
`static double`	`cos(double a)` Returns the trigonometric cosine of an angle.
`static double`	`exp(double a)` Returns Euler's number e raised to the power of a `double` value.
`static double`	`floor(double a)` Returns the largest (closest to positive infinity) `double` value that is not greater than the argument and is equal to a mathematical integer.
`static double`	`IEEEremainder(double f1, double f2)` Computes the remainder operation on two arguments as prescribed by the IEEE 754 standard.
`static double`	`log(double a)` Returns the natural logarithm (base e) of a `double` value.
`static double`	`max(double a, double b)` Returns the greater of two `double` values.
`static float`	`max(float a, float b)` Returns the greater of two `float` values.
`static int`	`max(int a, int b)` Returns the greater of two `int` values.
`static long`	`max(long a, long b)` Returns the greater of two `long` values.
`static double`	`min(double a, double b)` Returns the smaller of two `double` values.
`static float`	`min(float a, float b)` Returns the smaller of two `float` values.
`static int`	`min(int a, int b)` Returns the smaller of two `int` values.
`static long`	`min(long a, long b)` Returns the smaller of two `long` values.
`static double`	`pow(double a, double b)` Returns the value of the first argument raised to the power of the second argument.
`static double`	`random()` Returns a `double` value with a positive sign, greater than or equal to `0.0` and less than `1.0`.
`static double`	`rint(double a)` Returns the `double` value that is closest in value to the argument and is equal to a mathematical integer.
`static long`	`round(double a)` Returns the closest `long` to the argument.
`static int`	`round(float a)` Returns the closest `int` to the argument.
`static double`	`sin(double a)` Returns the trigonometric sine of an angle.
`static double`	`sqrt(double a)` Returns the correctly rounded positive square root of a `double` value.
`static double`	`tan(double a)` Returns the trigonometric tangent of an angle.
`static double`	`toDegrees(double angrad)` Converts an angle measured in radians to an approximately equivalent angle measured in degrees.
`static double`	`toRadians(double angdeg)` Converts an angle measured in degrees to an approximately equivalent angle measured in radians.

Field Detail

E

public static final double E

The double value that is closer than any other to e, the base of the natural alogarithms.

PI

public static final double PI

The double value that is closer than any other to pi, the ratio of the circumference of a circle to its diameter.

Method Detail

sin

public static double sin(double a)

Returns the trigonometric sine of an angle. Special cases:

If the argument is NaN or an infinity, then the result is NaN.
If the argument is zero, then the result is a zero with the same sign as the argument.

A result must be within 1 ulp of the correctly rounded result. Results must be semi-monotonic.

Parameters:: a - an angle, in radians.
Returns:: the sine of the argument.

cos

public static double cos(double a)

Returns the trigonometric cosine of an angle. Special cases:

If the argument is NaN or an infinity, then the result is NaN.

A result must be within 1 ulp of the correctly rounded result. Results must be semi-monotonic.

Parameters:: a - an angle, in radians.
Returns:: the cosine of the argument.

tan

public static double tan(double a)

Returns the trigonometric tangent of an angle. Special cases:

If the argument is NaN or an infinity, then the result is NaN.
If the argument is zero, then the result is a zero with the same sign as the argument.

A result must be within 1 ulp of the correctly rounded result. Results must be semi-monotonic.

Parameters:: a - an angle, in radians.
Returns:: the tangent of the argument.

asin

public static double asin(double a)

Returns the arc sine of an angle, in the range of -pi/2 through pi/2. Special cases:

If the argument is NaN or its absolute value is greater than 1, then the result is NaN.
If the argument is zero, then the result is a zero with the same sign as the argument.

A result must be within 1 ulp of the correctly rounded result. Results must be semi-monotonic.

Parameters:: a - the value whose arc sine is to be returned.
Returns:: the arc sine of the argument.

acos

public static double acos(double a)

Returns the arc cosine of an angle, in the range of 0.0 through pi. Special case:

If the argument is NaN or its absolute value is greater than 1, then the result is NaN.

A result must be within 1 ulp of the correctly rounded result. Results must be semi-monotonic.

Parameters:: a - the value whose arc cosine is to be returned.
Returns:: the arc cosine of the argument.

atan

public static double atan(double a)

Returns the arc tangent of an angle, in the range of -pi/2 through pi/2. Special cases:

If the argument is NaN, then the result is NaN.
If the argument is zero, then the result is a zero with the same sign as the argument.

A result must be within 1 ulp of the correctly rounded result. Results must be semi-monotonic.

Parameters:: a - the value whose arc tangent is to be returned.
Returns:: the arc tangent of the argument.

toRadians

public static double toRadians(double angdeg)

Converts an angle measured in degrees to an approximately equivalent angle measured in radians. The conversion from degrees to radians is generally inexact.

Parameters:: angdeg - an angle, in degrees
Returns:: the measurement of the angle angdeg in radians.

toDegrees

public static double toDegrees(double angrad)

Converts an angle measured in radians to an approximately equivalent angle measured in degrees. The conversion from radians to degrees is generally inexact; users should not expect cos(toRadians(90.0)) to exactly equal 0.0.

Parameters:: angrad - an angle, in radians
Returns:: the measurement of the angle angrad in degrees.

exp

public static double exp(double a)

Returns Euler's number e raised to the power of a double value. Special cases:

If the argument is NaN, the result is NaN.
If the argument is positive infinity, then the result is positive infinity.
If the argument is negative infinity, then the result is positive zero.

A result must be within 1 ulp of the correctly rounded result. Results must be semi-monotonic.

Parameters:: a - the exponent to raise e to.
Returns:: the value e^a, where e is the base of the natural logarithms.

log

public static double log(double a)

Returns the natural logarithm (base e) of a double value. Special cases:

If the argument is NaN or less than zero, then the result is NaN.
If the argument is positive infinity, then the result is positive infinity.
If the argument is positive zero or negative zero, then the result is negative infinity.

A result must be within 1 ulp of the correctly rounded result. Results must be semi-monotonic.

Parameters:: a - a number greater than 0.0.
Returns:: the value ln a, the natural logarithm of a.

sqrt

public static double sqrt(double a)

Returns the correctly rounded positive square root of a double value. Special cases:

If the argument is NaN or less than zero, then the result is NaN.
If the argument is positive infinity, then the result is positive infinity.
If the argument is positive zero or negative zero, then the result is the same as the argument.

Otherwise, the result is the double value closest to the true mathematical square root of the argument value.

Parameters:: a - a value.
Returns:: the positive square root of a. If the argument is NaN or less than zero, the result is NaN.

IEEEremainder

public static double IEEEremainder(double f1,
                                   double f2)

Computes the remainder operation on two arguments as prescribed by the IEEE 754 standard. The remainder value is mathematically equal to f1 - f2 × n, where n is the mathematical integer closest to the exact mathematical value of the quotient f1/f2, and if two mathematical integers are equally close to f1/f2, then n is the integer that is even. If the remainder is zero, its sign is the same as the sign of the first argument. Special cases:

If either argument is NaN, or the first argument is infinite, or the second argument is positive zero or negative zero, then the result is NaN.
If the first argument is finite and the second argument is infinite, then the result is the same as the first argument.

Parameters:: f1 - the dividend.; f2 - the divisor.
Returns:: the remainder when f1 is divided by f2.

ceil

public static double ceil(double a)

Returns the smallest (closest to negative infinity) double value that is not less than the argument and is equal to a mathematical integer. Special cases:

If the argument value is already equal to a mathematical integer, then the result is the same as the argument.
If the argument is NaN or an infinity or positive zero or negative zero, then the result is the same as the argument.
If the argument value is less than zero but greater than -1.0, then the result is negative zero.

Note that the value of Math.ceil(x) is exactly the value of -Math.floor(-x).

Parameters:: a - a value.
Returns:: the smallest (closest to negative infinity) floating-point value that is not less than the argument and is equal to a mathematical integer.

floor

public static double floor(double a)

Returns the largest (closest to positive infinity) double value that is not greater than the argument and is equal to a mathematical integer. Special cases:

If the argument value is already equal to a mathematical integer, then the result is the same as the argument.
If the argument is NaN or an infinity or positive zero or negative zero, then the result is the same as the argument.

Parameters:: a - a value.
Returns:: the largest (closest to positive infinity) floating-point value that is not greater than the argument and is equal to a mathematical integer.

rint

public static double rint(double a)

Returns the double value that is closest in value to the argument and is equal to a mathematical integer. If two double values that are mathematical integers are equally close, the result is the integer value that is even. Special cases:

If the argument value is already equal to a mathematical integer, then the result is the same as the argument.
If the argument is NaN or an infinity or positive zero or negative zero, then the result is the same as the argument.

Parameters:: a - a double value.
Returns:: the closest floating-point value to a that is equal to a mathematical integer.

atan2

public static double atan2(double y,
                           double x)

Converts rectangular coordinates (x, y) to polar (r, theta). This method computes the phase theta by computing an arc tangent of y/x in the range of -pi to pi. Special cases:

If either argument is NaN, then the result is NaN.
If the first argument is positive zero and the second argument is positive, or the first argument is positive and finite and the second argument is positive infinity, then the result is positive zero.
If the first argument is negative zero and the second argument is positive, or the first argument is negative and finite and the second argument is positive infinity, then the result is negative zero.
If the first argument is positive zero and the second argument is negative, or the first argument is positive and finite and the second argument is negative infinity, then the result is the double value closest to pi.
If the first argument is negative zero and the second argument is negative, or the first argument is negative and finite and the second argument is negative infinity, then the result is the double value closest to -pi.
If the first argument is positive and the second argument is positive zero or negative zero, or the first argument is positive infinity and the second argument is finite, then the result is the double value closest to pi/2.
If the first argument is negative and the second argument is positive zero or negative zero, or the first argument is negative infinity and the second argument is finite, then the result is the double value closest to -pi/2.
If both arguments are positive infinity, then the result is the double value closest to pi/4.
If the first argument is positive infinity and the second argument is negative infinity, then the result is the double value closest to 3*pi/4.
If the first argument is negative infinity and the second argument is positive infinity, then the result is the double value closest to -pi/4.
If both arguments are negative infinity, then the result is the double value closest to -3*pi/4.

A result must be within 2 ulps of the correctly rounded result. Results must be semi-monotonic.

Parameters:: y - the ordinate coordinate; x - the abscissa coordinate
Returns:: the theta component of the point (r, theta) in polar coordinates that corresponds to the point (x, y) in Cartesian coordinates.

pow

public static double pow(double a,
                         double b)

Returns the value of the first argument raised to the power of the second argument. Special cases:

If the second argument is positive or negative zero, then the result is 1.0.
If the second argument is 1.0, then the result is the same as the first argument.
If the second argument is NaN, then the result is NaN.
If the first argument is NaN and the second argument is nonzero, then the result is NaN.
If
- the absolute value of the first argument is greater than 1 and the second argument is positive infinity, or
- the absolute value of the first argument is less than 1 and the second argument is negative infinity,
then the result is positive infinity.
If
- the absolute value of the first argument is greater than 1 and the second argument is negative infinity, or
- the absolute value of the first argument is less than 1 and the second argument is positive infinity,
then the result is positive zero.
If the absolute value of the first argument equals 1 and the second argument is infinite, then the result is NaN.
If
- the first argument is positive zero and the second argument is greater than zero, or
- the first argument is positive infinity and the second argument is less than zero,
then the result is positive zero.
If
- the first argument is positive zero and the second argument is less than zero, or
- the first argument is positive infinity and the second argument is greater than zero,
then the result is positive infinity.
If
- the first argument is negative zero and the second argument is greater than zero but not a finite odd integer, or
- the first argument is negative infinity and the second argument is less than zero but not a finite odd integer,
then the result is positive zero.
If
- the first argument is negative zero and the second argument is a positive finite odd integer, or
- the first argument is negative infinity and the second argument is a negative finite odd integer,
then the result is negative zero.
If
- the first argument is negative zero and the second argument is less than zero but not a finite odd integer, or
- the first argument is negative infinity and the second argument is greater than zero but not a finite odd integer,
then the result is positive infinity.
If
- the first argument is negative zero and the second argument is a negative finite odd integer, or
- the first argument is negative infinity and the second argument is a positive finite odd integer,
then the result is negative infinity.
If the first argument is finite and less than zero
- if the second argument is a finite even integer, the result is equal to the result of raising the absolute value of the first argument to the power of the second argument
- if the second argument is a finite odd integer, the result is equal to the negative of the result of raising the absolute value of the first argument to the power of the second argument
- if the second argument is finite and not an integer, then the result is NaN.
If both arguments are integers, then the result is exactly equal to the mathematical result of raising the first argument to the power of the second argument if that result can in fact be represented exactly as a double value.

(In the foregoing descriptions, a floating-point value is considered to be an integer if and only if it is finite and a fixed point of the method ceil or, equivalently, a fixed point of the method floor. A value is a fixed point of a one-argument method if and only if the result of applying the method to the value is equal to the value.) A result must be within 1 ulp of the correctly rounded result. Results must be semi-monotonic.

Parameters:: a - the base.; b - the exponent.
Returns:: the value a^b.

round

public static int round(float a)

Returns the closest int to the argument. The result is rounded to an integer by adding 1/2, taking the floor of the result, and casting the result to type int. In other words, the result is equal to the value of the expression:

(int)Math.floor(a + 0.5f)

Special cases:

If the argument is NaN, the result is 0.
If the argument is negative infinity or any value less than or equal to the value of Integer.MIN_VALUE, the result is equal to the value of Integer.MIN_VALUE.
If the argument is positive infinity or any value greater than or equal to the value of Integer.MAX_VALUE, the result is equal to the value of Integer.MAX_VALUE.

Parameters:: a - a floating-point value to be rounded to an integer.
Returns:: the value of the argument rounded to the nearest int value.

round

public static long round(double a)

Returns the closest long to the argument. The result is rounded to an integer by adding 1/2, taking the floor of the result, and casting the result to type long. In other words, the result is equal to the value of the expression:

(long)Math.floor(a + 0.5d)

Special cases:

If the argument is NaN, the result is 0.
If the argument is negative infinity or any value less than or equal to the value of Long.MIN_VALUE, the result is equal to the value of Long.MIN_VALUE.
If the argument is positive infinity or any value greater than or equal to the value of Long.MAX_VALUE, the result is equal to the value of Long.MAX_VALUE.

Parameters:: a - a floating-point value to be rounded to a long.
Returns:: the value of the argument rounded to the nearest long value.

random

public static double random()

Returns a double value with a positive sign, greater than or equal to 0.0 and less than 1.0. Returned values are chosen pseudorandomly with (approximately) uniform distribution from that range. When this method is first called, it creates a single new pseudorandom-number generator, exactly as if by the expression

new java.util.Random

This new pseudorandom-number generator is used thereafter for all calls to this method and is used nowhere else. This method is properly synchronized to allow correct use by more than one thread. However, if many threads need to generate pseudorandom numbers at a great rate, it may reduce contention for each thread to have its own pseudorandom-number generator.

Returns:: a pseudorandom double greater than or equal to 0.0 and less than 1.0.

abs

public static int abs(int a)

Returns the absolute value of an int value. If the argument is not negative, the argument is returned. If the argument is negative, the negation of the argument is returned. Note that if the argument is equal to the value of Integer.MIN_VALUE, the most negative representable int value, the result is that same value, which is negative.

Parameters:: a - the argument whose absolute value is to be determined
Returns:: the absolute value of the argument.

abs

public static long abs(long a)

Returns the absolute value of a long value. If the argument is not negative, the argument is returned. If the argument is negative, the negation of the argument is returned. Note that if the argument is equal to the value of Long.MIN_VALUE, the most negative representable long value, the result is that same value, which is negative.

Parameters:: a - the argument whose absolute value is to be determined
Returns:: the absolute value of the argument.

abs

public static float abs(float a)

Returns the absolute value of a float value. If the argument is not negative, the argument is returned. If the argument is negative, the negation of the argument is returned. Special cases:

If the argument is positive zero or negative zero, the result is positive zero.
If the argument is infinite, the result is positive infinity.
If the argument is NaN, the result is NaN.

In other words, the result is the same as the value of the expression:

Float.intBitsToFloat(0x7fffffff & Float.floatToIntBits(a))

Parameters:: a - the argument whose absolute value is to be determined
Returns:: the absolute value of the argument.

abs

public static double abs(double a)

Returns the absolute value of a double value. If the argument is not negative, the argument is returned. If the argument is negative, the negation of the argument is returned. Special cases:

If the argument is positive zero or negative zero, the result is positive zero.
If the argument is infinite, the result is positive infinity.
If the argument is NaN, the result is NaN.

In other words, the result is the same as the value of the expression: Double.longBitsToDouble((Double.doubleToLongBits(a)<<1)>>>1)

Parameters:: a - the argument whose absolute value is to be determined
Returns:: the absolute value of the argument.

max

public static int max(int a,
                      int b)

Returns the greater of two int values. That is, the result is the argument closer to the value of Integer.MAX_VALUE. If the arguments have the same value, the result is that same value.

Parameters:: a - an argument.; b - another argument.
Returns:: the larger of a and b.

max

public static long max(long a,
                       long b)

Returns the greater of two long values. That is, the result is the argument closer to the value of Long.MAX_VALUE. If the arguments have the same value, the result is that same value.

Parameters:: a - an argument.; b - another argument.
Returns:: the larger of a and b.

max

public static float max(float a,
                        float b)

Returns the greater of two float values. That is, the result is the argument closer to positive infinity. If the arguments have the same value, the result is that same value. If either value is NaN, then the result is NaN. Unlike the the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero. If one argument is positive zero and the other negative zero, the result is positive zero.

Parameters:: a - an argument.; b - another argument.
Returns:: the larger of a and b.

max

public static double max(double a,
                         double b)

Returns the greater of two double values. That is, the result is the argument closer to positive infinity. If the arguments have the same value, the result is that same value. If either value is NaN, then the result is NaN. Unlike the the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero. If one argument is positive zero and the other negative zero, the result is positive zero.

Parameters:: a - an argument.; b - another argument.
Returns:: the larger of a and b.

min

public static int min(int a,
                      int b)

Returns the smaller of two int values. That is, the result the argument closer to the value of Integer.MIN_VALUE. If the arguments have the same value, the result is that same value.

Parameters:: a - an argument.; b - another argument.
Returns:: the smaller of a and b.

min

public static long min(long a,
                       long b)

Returns the smaller of two long values. That is, the result is the argument closer to the value of Long.MIN_VALUE. If the arguments have the same value, the result is that same value.

Parameters:: a - an argument.; b - another argument.
Returns:: the smaller of a and b.

min

public static float min(float a,
                        float b)

Returns the smaller of two float values. That is, the result is the value closer to negative infinity. If the arguments have the same value, the result is that same value. If either value is NaN, then the result is NaN. Unlike the the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero. If one argument is positive zero and the other is negative zero, the result is negative zero.

Parameters:: a - an argument.; b - another argument.
Returns:: the smaller of a and b.

min

public static double min(double a,
                         double b)

Returns the smaller of two double values. That is, the result is the value closer to negative infinity. If the arguments have the same value, the result is that same value. If either value is NaN, then the result is NaN. Unlike the the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero. If one argument is positive zero and the other is negative zero, the result is negative zero.

Parameters:: a - an argument.; b - another argument.
Returns:: the smaller of a and b.

Calculus: Newton's Method

Bisection Method: Example

Newton-Raphson Method: Example

Newton's Method: Example

Introduction to Computer Science and Programming

Java Programming Tutorial Multidimensional Arrays

What is Computer Science?

Computer science is a discipline that spans theory and practice. It requires thinking both in abstract terms and in concrete terms. The practical side of computing can be seen everywhere. Nowadays, practically everyone is a computer user, and many people are even computer programmers. Getting computers to do what you want them to do requires intensive hands-on experience. But computer science can be seen on a higher level, as a science of problem solving. Computer scientists must be adept at modeling and analyzing problems. They must also be able to design solutions and verify that they are correct. Problem solving requires precision, creativity, and careful reasoning. Computer science also has strong connections to other disciplines. Many problems in science, engineering, health care, business, and other areas can be solved effectively with computers, but finding a solution requires both computer science expertise and knowledge of the particular application domain. Thus, computer scientists often become proficient in other subjects.
Finally, computer science has a wide range of specialties. These include computer architecture, software systems, graphics, artifical intelligence, computational science, and software engineering. Drawing from a common core of computer science knowledge, each specialty area focuses on particular challenges.
Computer Science is practiced by mathematicians, scientists and engineers. Mathematics, the origins of Computer Science, provides reason and logic. Science provides the methodology for learning and refinement. Engineering provides the techniques for building hardware and software. Finally, and most importantly, computer scientists are computer scientists because it is fun. (Not to mention lucrative career opportunities!)
Another definition from http://www.csab.org/comp_sci_profession.html Computer Science: The Profession
Computer science is a discipline that involves the understanding and design of computers and computational processes. In its most general form it is concerned with the understanding of information transfer and transformation. Particular interest is placed on making processes efficient and endowing them with some form of intelligence. The discipline ranges from theoretical studies of algorithms to practical problems of implementation in terms of computational hardware and software.
A central focus is on processes for handling and manipulating information. Thus, the discipline spans both advancing the fundamental understanding of algorithms and information processes in general as well as the practical design of efficient reliable software and hardware to meet given specifications. Computer science is a young discipline that is evolving rapidly from its beginnings in the 1940's. As such it includes theoretical studies, experimental methods, and engineering design all in one discipline. This differs radically from most physical sciences that separate the understanding and advancement of the science from the applications of the science in fields of engineering design and implementation. In computer science there is an inherent intermingling of the theoretical concepts of computability and algorithmic efficiency with the modern practical advancements in electronics that continue to stimulate advances in the discipline. It is this close interaction of the theoretical and design aspects of the field that binds them together into a single discipline.
Because of the rapid evolution it is difficult to provide a complete list of computer science areas. Yet it is clear that some of the crucial areas are theory, algorithms and data structures, programming methodology and languages, and computer elements and architecture. Other areas include software engineering, artificial intelligence, computer networking and communication, database systems, parallel computation, distributed computation, computer-human interaction, computer graphics, operating systems, and numerical and symbolic computation.
A professional computer scientist must have a firm foundation in the crucial areas of the field and will most likely have an in-depth knowledge in one or more of the other areas of the discipline, depending upon the person's particular area of practice. Thus, a well educated computer scientist should be able to apply the fundamental concepts and techniques of computation, algorithms, and computer design to a specific design problem. The work includes detailing of specifications, analysis of the problem, and provides a design that functions as desired, has satisfactory performance, is reliable and maintainable, and meets desired cost criteria. Clearly, the computer scientist must not only have sufficient training in the computer science areas to be able to accomplish such tasks, but must also have a firm understanding in areas of mathematics and science, as well as a broad education in liberal studies to provide a basis for understanding the societal implications of the work being performed.

JDBC Tutorial

Computer Questions for CSE students

Dear viewers,I arranged a programming Exam contest

The selection procedure depends on-

Time of your answers submission
Correctness of your given answers.

To win a prize attempt the following question answers.

Exam - I

I. Answer the following questions. [10]

1. Write the use of the function while(). Give one example.
2. Write the function of for loop. Give one example.
3. Explain the use of conditional operator with the help of an example.
4. Why the if( ) statement is known as a conditional control statement? Explain your answer with the help of an example.
5. Why do……while( ) statement is known as “Enter looping” statement? Explain your answer with the help of an example.
II. Fill in the blanks. [10]
1. ----------- symbol is used as unsigned right shift operator.
2. & is used for -------------------------- .
3. ------------------ Symbol is used for bit wise XOR.
4. The symbol , (comma) is used as ------------------------- .
5. << symbol is used as --------------------------- .
6. If int a = 23 and b = 7 then the value of a % b is --------------.
6. -------------- is the symbol for ternary operator .
7. If int a = 5 , int b = 2 and int c = a / b . then value of c is ----------------.
8. If x = 3 and x = (++ x) + (x++) then value of x after evaluation is -------- .
9. If a = 34 , b = 23 and int k = (34 > 23)? a : b ; then value of k is ------.
10. The symbol ( ~ ) is used for ---------------------

The prize will be sent to your mobile phone as a flexi load/balance transfer.

Contestant must submit their answers with cell number [for Bangladeshi contestant only]
Send your answer only to this email: ahmmad.cse@gmail.com

Data Update task of DBMS

An SQL UPDATE statement changes the data of one or more records in a table. Either all the rows can be updated, or a subset may be chosen using a condition.
The UPDATE statement has the following form

UPDATE table_name SET column_name = value [, column_name = value ...] [WHERE condition]

For the UPDATE to be successful, the user must have data manipulation privileges (UPDATE privilege) on the table or column, the updated value must not conflict with all the applicable constraints (such as primary keys, unique indexes, CHECK constraints, and NOT NULL constraints).
In some databases, as PostgreSQL, when a FROM clause is present, what essentially happens is that the target table is joined to the tables mentioned in the fromlist, and each output row of the join represents an update operation for the target table. When using FROM you should ensure that the join produces at most one output row for each row to be modified. In other words, a target row shouldn't join to more than one row from the other table(s). If it does, then only one of the join rows will be used to update the target row, but which one will be used is not readily predictable.
Because of this indeterminacy, referencing other tables only within sub-selects is safer, though often harder to read and slower than using a join.

Examples

Set the value of column C1 in table T to 1, only in those rows where the value of column C2 is "a".

UPDATE T SET C1 = 1 WHERE C2 = 'a'

In table T, set the value of column C1 to 9 and the value of C3 to 4 for all rows for which the value of column C2 is "a".

UPDATE T SET C1 = 9, C3 = 4 WHERE C2 = 'a'

Increase value of column C1 by 1 if the value in column C2 is "a".

UPDATE T SET C1 = C1 + 1 WHERE C2 = 'a'

Prepend the value in column C1 with the string "text" if the value in column C2 is "a".

UPDATE T SET C1 = 'text' || C1 WHERE C2 = 'a'

Set the value of column C1 in table T1 to 2, only if the value of column C2 is found in the sub list of values in column C3 in table T2 having the column C4 equal to 0.

UPDATE T1

SET    C1 = 2

WHERE  C2 IN ( SELECT C3

               FROM   T2

               WHERE  C4 = 0)

You may also update multiple columns in a single update statement:

UPDATE T SET C1 = 1, C2 = 2

Complex conditions and JOINs are also possible:

UPDATE T SET A = 1 WHERE C1 = 1 AND C2 = 2

UPDATE a

SET a.[updated_column] = updatevalue

FROM articles a

JOIN classification c

ON a.articleID = c.articleID

WHERE c.classID = 1

Or on Oracle-systems

UPDATE (

SELECT *

  FROM articles a

  JOIN classification c

    ON a.articleID = c.articleID

) AS a

SET a.[updated_column] = updatevalue

WHERE c.classID = 1

References

http://dev.mysql.com/doc/refman/5.0/en/update.html http://www.postgresql.org/docs/8.1/static/sql-update.html

An election is contested by 5 caddidates.The candidates are numbered 1 to 5 and the voting is done by marking the candidate number on the ballot paper.Write a program to read the ballots and count the votes cast for each candidate using an array variable count.In case, a number read is outside the range 1 to 5,the ballot should be considered as a ‘spoilt’ and the program should also count the number of spoilt ballots

import java.io.*;

class election

{

public static void main(String args[])throws

IOException

{

DataInputStream in = new

DataInputStream(System.in);

int i,n,a=0,spoilt=0;

System.out.print("Enter number of ballots: ");

n = Integer.parseInt(in.readLine());

System.out.println();

int count[] = new int[n];

for(i=0;i

{

System.out.print("Enter Vote: ");

count[i] = Integer.parseInt(in.readLine());

if( count[i] == 1 || count[i] == 2 || count[i] == 3 || count[i] == 4 || count[i] ==5)

a++;

else

{

System.out.println("\t\tOutside the range");

spoilt++;

}

System.out.println("bollte paper: " + a);

System.out.println("spoilt parep: " + spoilt);

}

Write a program to read the data and determine the following (a)Total marks obtained by each student.(b)The highest marks in each subject and the roll no.of the student who secured it(c)the student obtained the highest total marks

import java.io.*;
class StudentResult
{

int result[][]=new int[100][5];

int i,j,k,total,maxr,maxm;

BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

public void takeData() throws IOException

{
for(i=0;i< 100;i++)
{
total=0; for(j=0;j< 4;j++)
{
if(j==0)
System.out.println("Enter Roll number\t");
else if(j==1)
System.out.println ("Enter 1st subject marks\t");
else if(j==2)
System.out.println ("Enter 2nd subject marks\t");
else if(j==3)
System.out.println ("Enter 3rd subject marks\t");
result[i][j]=Integer.parseInt(br.readLine());
if(j!=0) total+=result[i][j];
}
result[i][j]=total;
}
}
public void showResult()
{
System.out.println ("Mark sheet");
System.out.println ("\nRoll 1st 2nd 3rd Total");
for(i=0;i<100;i++)
{
for(j=0;j< 5;j++)
{
System.out.println (" "+result[i][j]);
}
System.out.println ();
}
System.out.println ("\n\n");
System.out.println ("Roll number with total");
System.out.println("\nRoll Total");
for(i=0;i<100;i++)
{
for(j=0;j<5;j++)
{
if((j==0)||(j==4))
System.out.println (" "+result[i][j]);
}
System.out.println ();
}
for(i=1;i< 4;i++)
{
for(j=0;j< 100;j++)
{
if(j==0)
{
maxm=result[j][i]; maxr=result[j][0];
}
else if(result[j][i]>maxm)
{
maxm=result[j][i];
maxr=result[j][0];
}
}
if(i==1)
System.out.println ("\nMaximum marks in sub1 is :"+maxm + ""+maxr);
else if(i==2)
System.out.println ("\nMaximum marks in sub2 is :"+maxm + " "+maxr);
else if(i==3)
System.out.println ("\nMaximum marks in sub3 is :"+maxm + " "+maxr);
}
for(i=0;i< 100;i++)
{
for(j=0;j< 5;j++)
{
if(j==4)
{
if(i==0)
{
maxm=result[i][j]; maxr=result[i][0];
}
else if(result[i][j]>maxm)
{
maxm=result[i][j];
maxr=result[i][0];
}
}
}
}
System.out.println ("\nMaximum total is :"+maxm + " "+maxr);
}
}

#### What is HTML?Hyper Text Markup Language

HTML is a computer language devised to allow website creation. These websites can then be viewed by anyone else connected to the Internet. It is relatively easy to learn, with the basics being accessible to most people in one sitting; and quite powerful in what it allows you to create. The definition of HTML is Hyper Text Markup Language.

Hyper Text is the method by which you move around on the web — by clicking on special text called hyperlinks which bring you to the next page. The fact that it is hyper just means it is not linear — i.e. you can go to any place on the Internet whenever you want by clicking on links — there is no set order to do things in.
Markup is what HTML tags do to the text inside them. They mark it as a certain type of text (italicized text, for example).
HTML is a Language, as it has code-words and syntax like any other language.

How does it work?

HTML consists of a series of short codes typed into a text-file by the site author — these are the tags. The text is then saved as a html file, and viewed through a browser, like Internet Explorer or Netscape Navigator. This browser reads the file and translates the text into a visible form, hopefully rendering the page as the author had intended. Writing your own HTML entails using tags correctly to create your vision. You can use anything from a rudimentary text-editor to a powerful graphical editor to create HTML pages.

Why is Java known as platform-neutral language?

Plateform neutral or platform independence, means that programs written in the Java language must run similarly on any supported hardware/operating-system platform. A programmer should be able to write a program one time, compile it one time, and then be able to execute it anywhere; holding true to the Sun Microsystems slogan, "Write Once, Run Anywhere. "ava was designed to not only be cross-platform in source form like C, but also in compiled binary form. Since this is frankly impossible across processor architectures Java is compiled to an intermediate form called byte-code. A Java program never really executes natively on the host machine. Rather a special native program called the Java interpreter reads the byte code and executes the corresponding native machine instructions. Thus to port Java programs to a new platform all that is needed is to port the interpreter and some of the library routines. Even the compiler is written in Java. The byte codes are precisely defined, and remain the same on all platforms.

Java is used in many facets, from the digital displays on our microwaves and refrigerators in our kitchen to the digital displays on our telephones, fax machines, and copiers in our office. It is used on the web (via applets

A least five major C++ features that were intentionally removed from JAVA

C++ Features Not Found in Java

C++ supports multiple inheritance of method implementations from more than one superclass at a time. While this seems like a useful feature, it actually introduces many complexities to the language. The Java language designers chose to avoid the added complexity by using interfaces instead. Thus, a class in Java can inherit method implementations only from a single superclass, but it can inherit method declarations from any number of interfaces.

C++ supports templates that allow, for example, to implement a Stack class and then instantiate it as Stack or Stack to produce two separate types: a stack of integers and a stack of floating-point values. Java does not allow this, but efforts are underway to add this feature to the language in a robust and standardized way. Furthermore, the fact that every class in Java is a subclass of Object means that every object can be cast to an instance of Object. Thus, in Java it is often sufficient to define a data structure (such as a Stack class) that operates on Object values; the objects can be cast back to their actual types whenever necessary.

C++ allows to define operators that perform arbitrary operations on instances of our classes. In effect, it allows to extend the syntax of the language. This is a nifty feature, called operator overloading, that makes for elegant examples. In practice, however, it tends to make code quite difficult to understand. After much debate, the Java language designers decided to omit such operator overloading from the language. Note, though, that the use of the + operator for string concatenation in Java is at least reminiscent of operator overloading.

C++ allows to define conversion functions for a class that automatically invoke an appropriate constructor method when a value is assigned to a variable of that class. This is simply a syntactic shortcut (similar to overriding the assignment operator) and is not included in Java.

In C++, objects are manipulated by value by default; we must use & to specify a variable or function argument automatically manipulated by reference. In Java, all objects are manipulated by reference, so there is no need for this & syntax.

Keyword

Followers

Feedjit

java.lang Class Math

E

PI

sin

cos

tan

asin

acos

atan

toRadians

toDegrees

exp

log

sqrt

IEEEremainder

ceil

floor

rint

atan2

pow

round

round

random

abs

abs

abs

abs

max

max

max

max

min

min

min

min

What is Computer Science?

Examples

References

How does it work?

Collect Java Books

Blog Archive

java.lang
Class Math