Question

This is C++ programming.

Create the following files: point.h – contains the definition for the point struct. A point consists of an x and y coordinate line.h – contains the definition and prototypes for the line class. A line consists of two points. Getters and setters are not required. However, you do need: 1. A constructor 2. A slope method, which returns the slope of the line 3. An intersect with method, which calculates, and returns, the point of intersec- tion with another line, if it exists line.cpp - contains the method definitions for the line class. Some notes: slope – return NAN (Not-A-Number) if the line is vertical intersect with — return the point (NAN, NAN) (both x and y coordinates are Not- A-Number) if the two lines are parallel main.cpp — make a main method which includes unit testing for the line class. Have at least 3 unit tests for slope (including at least 1 where the line is vertical) and at least 3 unit tests for intersect_with (including at least 1 where the lines are parallel) You may have forgotten your grade 9 algebra. Here's how you calculate slope and point of intersection. If the line is not vertical, slope is calculated as m= = To calculate the point of intersection between the two lines, you need to also calculate the y-intercept (b) for each line. This can be calculated as b = y - mr where and y are the coordinates of either point defining the line. Once you have a slope for both lines and a y-intercept for both lines, the point of intersection can be calculated as x = high, and then = mx +b (using the slope/y-intercept of either line). y

Answer 1

program code to copy

main.cpp

#include "line.h";
#include <iostream>
using namespace std;

int main()
{
        //test slope 1
        point p1;
        p1.x = 0;
        p1.y = 1;
        point p2;
        p2.x = 1;
        p2.y = 3;
        line l1(p1,p2);
        cout << "Slope should be 2:" << endl;
        cout <<"Slope: "<< l1.slope()<<endl;

        //test slope 2
        point p3;
        p3.x = 0;
        p3.y = 1;
        point p4;
        p4.x = 0;
        p4.y = 4;
        line l2(p3, p4);
        cout << "Slope should be NaN:" << endl;
        cout << "Slope: " << l2.slope() << endl;

        //test slope 3
        point p5;
        p5.x = 2;
        p5.y = 2;
        point p6;
        p6.x = 4;
        p6.y = 2;
        line l3(p5, p6);
        cout << "Slope should be 0:" << endl;
        cout << "Slope: " << l3.slope() << endl;

        //test slope 4
        point p7;
        p7.x = 2;
        p7.y = 3;
        point p8;
        p8.x = 4;
        p8.y = 1;
        line l4(p7, p8);
        cout << "Slope should be -1:" << endl;
        cout << "Slope: " << l4.slope() << endl;

        //test for intersect_with() 1
        p1.x = 0;
        p1.y = 1;
        p2.x = 1;
        p2.y = 3;
        line l5(p1, p2);

        p3.x = 0;
        p3.y = 4;
        p4.x = 2;
        p4.y = 0;
        line l6(p3, p4);
        cout << "Intersection of l5( (" << p1.x << " , " << p1.y << " )"  << " , (" << p2.x << " , " << p2.y << ") ) and " << "l6( (" << p3.x << ", " << p3.y << ")" << ", (" << p4.x << ", " << p4.y << ") )" << endl;
        cout << "( "<<l5.intersect_with(l5, l6).x << " , " << l5.intersect_with(l5, l6).y << " )" << endl;


        //test for intersect_with() 2
        p1.x = 0;
        p1.y = 1;
        p2.x = 3;
        p2.y = 3;
        line l7(p1, p2);

        p3.x = 0;
        p3.y = 4;
        p4.x = 0;
        p4.y = 0;
        line l8(p3, p4);
        cout << "Intersection of l7( (" << p1.x << " , " << p1.y << ")" << " , (" << p2.x << " , " << p2.y << ") ) and " << "l8( (" << p3.x << ", " << p3.y << ")" << ", (" << p4.x << ", " << p4.y << ") )" << endl;
        cout <<"Intersection point: "<< "(" << l7.intersect_with(l7, l8).x << " , " << l7.intersect_with(l7, l8).y << ")" << endl;


        //test for intersect_with() 2
        p1.x = 0;
        p1.y = 1;
        p2.x = 2;
        p2.y = 5;
        line l9(p1, p2);

        p3.x = 1;
        p3.y = 0;
        p4.x = 2;
        p4.y = 2;
        line l10(p3, p4);
        cout << "Intersection of l9( (" << p1.x << " , " << p1.y << ")" << " , (" << p2.x << " , " << p2.y << ") ) and " << "l10( (" << p3.x << " , " << p3.y << ")" << " , (" << p4.x << " , " << p4.y << ") )" << endl;
        cout <<"Intersection point: "<< "(" << l9.intersect_with(l9, l10).x << " , " << l9.intersect_with(l9, l10).y << ")" << endl;

}

===============================================================================================

line.h

#include "point.h";
class line 
{
        private:
                point p1;
                point p2;
        public:
                line(struct point p1,struct point p2);
                //parameters: none
                //return: slope of the two points
                const double slope();
                //parameters: line l1, line l2
                //return: point of intersection between these two lines
                const point intersect_with(line l1,line l2);
};

=======================================================================

line.cpp

#include <iostream>
#include <cmath>
#include "line.h";
using namespace std;

line::line(const struct point p1,const struct point p2) 
{
        this->p1 = p1;
        this->p2 = p2; 
}
const double line::slope() 
{
        if (this->p1.x == this->p2.x) return std::nan("");
        return ((this->p2.y - this->p1.y) / (this->p2.x - this->p1.x));
}


const point line::intersect_with(line l1, line l2) 
{
        if (isnan(l1.slope()) && isnan(l2.slope()))
        {
                point pq;
                pq.x = std::numeric_limits<double>::quiet_NaN();
                pq.y = std::numeric_limits<double>::quiet_NaN();
                return pq;
        }
        else if (isnan(l1.slope()) || isnan(l2.slope())) 
        {
                        if (isnan(l1.slope())) 
                        {
                                cout << "First line is vertical!" << endl;
                                double b2 = l2.p1.y - (l2.slope() * l2.p1.x);
                                point pi;
                                pi.x = l1.p1.x;
                                pi.y = l2.slope() * pi.x + b2;
                                return pi;
                        }
                        else 
                        {
                                cout << "Secont line is vertical!" << endl;
                                double b1 = l1.p1.y - (l1.slope() * l1.p1.x);
                                point pi;
                                pi.x = l2.p1.x;
                                pi.y = l1.slope() * pi.x + b1;
                                return pi;
                        }
        }
        else if (l1.slope() == l2.slope()) 
        {
                point pi;
                pi.x = std::nan("");
                pi.y = std::nan("");
                return pi;
        }
        else 
        {
                double b1 = l1.p1.y - (l1.slope() * l1.p1.x);
                double b2 = l2.p1.y - (l2.slope() * l2.p1.x);
                point pi;
                pi.x = (b1 - b2) / (l2.slope() - l1.slope());
                pi.y = l2.slope() * pi.x + b2;
                return pi;
        }

}


============================================================================

point.h

struct point 
{
        double x;
        double y; 
};

sample output

slope should be 2: slope: 2 slope should be NaN: slope: nan slope should be 0: slope: 0 slope should be -1: slope: -1 Intersection of 15 (0, 1), (1, 3)) and 16( (0, 4), (2, 0)) (0.75, 2.5) Intersection of 17( (0, 1), (3, 3)) and 18( (0, 4), (0, 0)) Intersection point: (Secont line is vertical! 0, Secont line is vertical! 1) Intersection of 19( (0, 1), (2,5)) and 110( (1,0), (2, 2)) Intersection point: (nan, nan)