1.Fraction that has a numerator and a denominator. The class should
have methods that can:
(a) add and subtract two Fractions together and
return the resulting Fraction,
(b) create a duplicate of itself and return the duplicate,
(c) see if another Fraction is equivalent to itself and return True or False appropriately and
(d) reduce itself to the lowest equivalent Fraction.
.
What are you supposed to do for the exercise - pseudocode, public class,...?
Can you pin-point your difficulty with the problem.
Is it the logic or the syntax that gives you problems? I assume you are programming in Java?
Sorry, It's Java, and I am suppose to
write a class to represent one of the following items. Note that each class must a proper constructor even though the constructor is not explicitly named.
So you start off with defining the public class, the instance variables, and the constructors. If you define a constructor with parameters, it is always preferable to define one without to replace the default constructor.
A constructor has the same name as the class, and has no return type.
To make a (shallow) copy of an instance, you will need a copy constructor, which is a constructor which has a single parameter of type equal to the class, such as:
public Fraction(Fraction f){....}
I'll get you started. Post your code if you have difficulties.
public class Fraction
{
// instance variables
private int numerator;
private int denominator;
// constructors
public Fraction()
{ // default constructor, do nothing
}
public Fraction(Fraction original)
{
// write your code here
}
// write your constructor here
// write your other methods here
public static void main(String[] args)
{
// write your code to test the class
}
}
To implement a fraction class with the specified methods, you can use the following approach:
1. Create a class named `Fraction`. Provide two instance variables, `numerator` and `denominator`, to represent the numerator and denominator of the fraction.
```python
class Fraction:
def __init__(self, numerator, denominator):
self.numerator = numerator
self.denominator = denominator
```
2. Implement the addition and subtraction methods. To add or subtract two fractions, you need to find a common denominator, perform the operation on the numerators, and simplify the result using the lowest common denominator. You can achieve this by following these steps:
- Find the lowest common denominator (LCD) between the two fractions.
- Multiply each fraction's numerator and denominator by the necessary factor to make their denominators equal to the LCD.
- Add/subtract the numerators together to get the new numerator.
- Create and return a new fraction with the simplified numerator and denominator.
```python
def add(self, other):
lcd = self.denominator * other.denominator
numerator = (self.numerator * other.denominator) + (other.numerator * self.denominator)
return Fraction(numerator, lcd)
def subtract(self, other):
lcd = self.denominator * other.denominator
numerator = (self.numerator * other.denominator) - (other.numerator * self.denominator)
return Fraction(numerator, lcd)
```
3. Implement the `duplicate` method to generate a duplicate of the current fraction object by returning a new instance with the same numerator and denominator.
```python
def duplicate(self):
return Fraction(self.numerator, self.denominator)
```
4. Implement the `is_equivalent` method to check if another fraction is equivalent to the current fraction. To do this, compare the ratios of the numerators and denominators.
```python
def is_equivalent(self, other):
return self.numerator * other.denominator == other.numerator * self.denominator
```
5. Implement the `reduce` method to reduce the fraction to its lowest equivalent form. This can be done by dividing both the numerator and denominator by their greatest common divisor (GCD).
```python
def reduce(self):
gcd = self._gcd(self.numerator, self.denominator)
return Fraction(self.numerator // gcd, self.denominator // gcd)
def _gcd(self, a, b):
while b != 0:
a, b = b, a % b
return a
```
By implementing these methods in the `Fraction` class, you will have a functioning class that can perform addition, subtraction, duplication, equivalence checking, and fraction reduction.