Lab1

java.lang.Object
- eecs2030.lab1.Lab1

```
public class Lab1
extends java.lang.Object
```
Short methods reviewing fundamental Java concepts covered in EECS1021, EECS1022, and EECS1720

Field Summary

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`COURSE_NAME` The course name for EECS2030.
`static int`	`DEGREES_IN_CIRCLE` The number of degrees in a circle.
`static int`	`QUARTER_VALUE` The number of cents equal to a Canadian quarter coin.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static double`	`avg(int a, int b)` Compute the average of two values.
`static char`	`charFromEnd(java.lang.String s, int n)` Returns the character n positions from the end of the string s.
`static int`	`compareTo(Range r1, Range r2)` Compares two `Range` instances by their widths.
`static int`	`contains(double x, Range range)` Determine if a value `x` is strictly inside the given `Range`.
`static int`	`frequency(java.util.List<java.lang.String> t, java.lang.String target)` Returns the number of strings in the list t that are equal to the target string.
`static java.lang.String`	`getCourseName()` Returns the course name as the string.
`static boolean`	`isEven(int x)` Determine if an integer `x` is even.
`static boolean`	`isGradeA(double percent)` Returns true if the given grade in percent is equal to a letter grade of A, and false otherwise.
`static boolean`	`isGradeOutOfRange(double percent)` Returns true if the given grade in percent is outside the range of normal grades (less than 0 or greater than 100), and false otherwise.
`static boolean`	`isInsideUnitCircle(double x, double y)` Determine if the point `(x, y)` is inside the perimeter of a circle with center `(0, 0)` and having radius equal to `1`.
`static boolean`	`isLeapYear(int year)` Returns true if year is a leap year and false otherwise.
`static boolean`	`isPythagTriple(int a, int b, int c)` Given three integers: a, b, and c; return true only if they can form a Pythagorean triple.
`static int`	`maxInt()` Returns the maximum (most positive) value that an `int` can represent.
`static double`	`minDouble()` Returns the minimum positive value greater than zero that a `double` can represent.
`static double`	`normal(double x)` Computes the standard normal distribution probability density function (see the lab document for the actual formula).
`static int`	`numQuarters(int cents)` Returns the largest number of Canadian quarters (each worth 25 cents) whose total value does not exceed the given number of cents.
`static void`	`repair(java.util.List<java.lang.Integer> t)` Sorts the elements of the list t so that the elements are in ascending order.
`static void`	`sort2(java.util.List<java.lang.Integer> t)` Sorts a list of two integers so that the elements are in descending order (largest to smallest).
`static java.lang.String`	`toString(Range r)` Returns a string representation of a `Range` that is different than the one returned by `Range.toString`.
`static int`	`wrapAngle(int degrees)` Wraps an angle given in degrees so that it lies in the range of -359 degrees to 359 degrees.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - COURSE_NAME
```
public static final java.lang.String COURSE_NAME
```
    The course name for EECS2030.
    
    See Also:
    
    Constant Field Values
  - QUARTER_VALUE
```
public static final int QUARTER_VALUE
```
    The number of cents equal to a Canadian quarter coin.
    
    See Also:
    
    Constant Field Values
  - DEGREES_IN_CIRCLE
```
public static final int DEGREES_IN_CIRCLE
```
    The number of degrees in a circle.
    
    See Also:
    
    Constant Field Values
- Method Detail
  - maxInt
```
public static int maxInt()
```
    Returns the maximum (most positive) value that an int can represent.
    
    Returns:
    
    the maximum (most positive) value that an int can represent
  - minDouble
```
public static double minDouble()
```
    Returns the minimum positive value greater than zero that a double can represent.
    
    Returns:
    
    the minimum positive value greater than zero that a double can represent
  - numQuarters
```
public static int numQuarters(int cents)
```
    Returns the largest number of Canadian quarters (each worth 25 cents) whose total value does not exceed the given number of cents.
    
    Parameters:
    
    cents - a positive number of cents
    
    Returns:
    
    the largest number of Canadian quarters (each worth 25 cents) whose total value does not exceed the given number of cents
  - wrapAngle
```
public static int wrapAngle(int degrees)
```
    Wraps an angle given in degrees so that it lies in the range of -359 degrees to 359 degrees. For example:
```
 degrees      wrapAngle(degrees) returns
  0            0
  1            1
 -1           -1
  359          359
 -359         -359
  360          0    (wraps around to 0 degree)
 -360          0    (wraps around to 0 degree)
  361          1    (wraps around to 1 degree)
 -361         -1    (wraps around to -1 degree)
  725          5    (wraps around to 5 degrees)
 -730         -10   (wraps around to -10 degrees)
  3652         52   (wraps around to 52 degrees)
 
```
    Parameters:
    
    degrees - an angle in degrees
    
    Returns:
    
    the angle wrapped to the interval -359 to 359 degrees
  - avg
```
public static double avg(int a,
                         int b)
```
    Compute the average of two values.
    
    Parameters:
    
    a - a value
    
    b - a second value
    
    Returns:
    
    the average of the two values
  - normal
```
public static double normal(double x)
```
    Computes the standard normal distribution probability density function (see the lab document for the actual formula).
    
    Parameters:
    
    x - a value
    
    Returns:
    
    the standard normal distribution probability density function evaluated at x
  - isEven
```
public static boolean isEven(int x)
```
    Determine if an integer x is even.
    
    Parameters:
    
    x - a value
    
    Returns:
    
    true if x is even and false otherwise
  - isInsideUnitCircle
```
public static boolean isInsideUnitCircle(double x,
                                         double y)
```
    Determine if the point (x, y) is inside the perimeter of a circle with center (0, 0) and having radius equal to 1.
    
    Parameters:
    
    x - the x-coordinate of the point
    
    y - the y-coordinate of the point
    
    Returns:
    
    true if (x, y) is inside the perimeter of the unit circle, and false otherwise
  - isGradeA
```
public static boolean isGradeA(double percent)
```
    Returns true if the given grade in percent is equal to a letter grade of A, and false otherwise. The minimum percent grade for a letter grade of A is 80 and the minimum percent grade for a letter grade of A+ is 90.
    
    Parameters:
    
    percent - a grade in percent
    
    Returns:
    
    true if the given grade in percent is equal to a letter grade of A, and false otherwise
  - isGradeOutOfRange
```
public static boolean isGradeOutOfRange(double percent)
```
    Returns true if the given grade in percent is outside the range of normal grades (less than 0 or greater than 100), and false otherwise.
    
    Parameters:
    
    percent - a grade in percent
    
    Returns:
    
    true if the given grade in percent is outside the range of normal grades, and false otherwise
  - isLeapYear
```
public static boolean isLeapYear(int year)
```
    Returns true if year is a leap year and false otherwise.
    A year is always a leap year if it is evenly divisible by 400; for all other years, a year is a leap year if it is evenly divisible by 4 and not evenly divisible by 100. For example:
```
 isLeapYear(2000)  returns  true   (2000 is divisible by 400)
 isLeapYear(1900)  returns  false  (1900 is divisible by 4 and 100)
 isLeapYear(2004)  returns  true   (2004 is divisible by 4 but not 100)
 isLeapYear(2005)  returns  false  (2005 is not divisible by 4)
 
```
    Parameters:
    
    year - a year
    
    Returns:
    
    true if year is a leap year and false otherwise
    
    Throws:
    
    java.lang.IllegalArgumentException - if year is less than 1582 (the year the Gregorian calendar was adopted)
  - contains
```
public static int contains(double x,
                           Range range)
```
    Determine if a value x is strictly inside the given Range. A value exactly at the minimum or maximum of the range is considered outside of the range.
    
    Parameters:
    
    x - a value
    
    range - a Range to check
    
    Returns:
    
    the value 1 if x is strictly inside the given Range, and 0 otherwise
  - compareTo
```
public static int compareTo(Range r1,
                            Range r2)
```
    Compares two Range instances by their widths.
    
    Parameters:
    
    r1 - a Range
    
    r2 - a second Range
    
    Returns:
    
    the value 0 if both Range instances are equal; -1 if r1 is narrower than r2; and 1 if r1 is wider than r2
  - getCourseName
```
public static java.lang.String getCourseName()
```
    Returns the course name as the string.
    
    Returns:
    
    the string equal to Lab1.COURSE_NAME
  - toString
```
public static java.lang.String toString(Range r)
```
    Returns a string representation of a Range that is different than the one returned by Range.toString.
    The returned string has the form "minimum: x, maximum: y" where x is the minimum value of the range and y is the maximum value of the range.
    
    Parameters:
    
    r - a Range instance
    
    Returns:
    
    a string representation of the range
  - charFromEnd
```
public static char charFromEnd(java.lang.String s,
                               int n)
```
    Returns the character n positions from the end of the string s. For example, suppose s is the string "abcd"; then:
```
 Lab1.charFromEnd(s, 0)  returns 'd'
 Lab1.charFromEnd(s, 1)  returns 'c'
 Lab1.charFromEnd(s, 2)  returns 'b'
 Lab1.charFromEnd(s, 3)  returns 'a'
 Lab1.charFromEnd(s, 4)  throws an IllegalArgumentException
 Lab1.charFromEnd(s, -1) throws an IllegalArgumentException
 
```
    Parameters:
    
    s - a string of length 1 or greater
    
    n - the desired location of the character counting from the end of the string
    
    Returns:
    
    the character located n positions from the end of the string
    
    Throws:
    
    java.lang.IllegalArgumentException - if the character located n positions from the end of the string does not exist
  - sort2
```
public static void sort2(java.util.List<java.lang.Integer> t)
```
    Sorts a list of two integers so that the elements are in descending order (largest to smallest). The size of the list remains unchanged.
    
    Parameters:
    
    t - a list
    
    Throws:
    
    java.lang.IllegalArgumentException - if the size of list is not equal to 2
  - frequency
```
public static int frequency(java.util.List<java.lang.String> t,
                            java.lang.String target)
```
    Returns the number of strings in the list t that are equal to the target string.
    
    Parameters:
    
    t - the list to search
    
    target - the string to search for
    
    Returns:
    
    the number of strings in the list t that are equal to target
  - repair
```
public static void repair(java.util.List<java.lang.Integer> t)
```
    Sorts the elements of the list t so that the elements are in ascending order. A precondition of this method is that t must be already sorted in ascending order except that adjacent pairs of elements in t may be out of order. Consider the following almost sorted lists:
```
 [1, 0]                1, 0 is out of order
 [0, 2, 1]             2, 1 is out of order
 [0, 2, 1, 3]          2, 1 is out of order
 [0, 2, 1, 4, 3]       2, 1 and 4, 3 are out of order
 [0, 1, 3, 2, 4]       3, 2 is out of order
 
```
    This method switches the positions of the out-of-order adjacent elements thus repairing the list so that it is in sorted order.
    Parameters:
    
    t - a list of almost sorted elements
    
    Precondition:
    
    t is sorted in ascending order except that adjacent pairs of elements may be out of order
  - isPythagTriple
```
public static boolean isPythagTriple(int a,
                                     int b,
                                     int c)
```
    Given three integers: a, b, and c; return true only if they can form a Pythagorean triple. "Pythagorean triples" are integer solutions to the Pythagorean Theorem, a^2 + b^2 = c^2 A precondition of this method is that none of a, b, and c must not be zero. Consider the following examples:
```
 isPythagTriple(4,3,5)    output: true
 isPythagTriple(5,3,4)    output: true
 isPythagTriple(6,3,5)    output: false
 isPythagTriple(1,1,2)    output: false
 
```
    Parameters:
    
    a - an integer number in the triple
    
    b - an integer number in the triple
    
    c - an integer number in the triple
    
    Returns:
    
    true if a, b, and c can be integer solutions to the Pythagorean Theorem
    
    Throws:
    
    java.lang.IllegalArgumentException - if a, b, or c is zero
    
    Precondition:
    
    none of a, b, and c; is zero.

Class Lab1

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

COURSE_NAME

QUARTER_VALUE

DEGREES_IN_CIRCLE

Method Detail

maxInt

minDouble

numQuarters

wrapAngle

avg

normal

isEven

isInsideUnitCircle

isGradeA

isGradeOutOfRange

isLeapYear

contains

compareTo

getCourseName

toString

charFromEnd

sort2

frequency

repair

isPythagTriple