C / C++ / MFC

#include <iostream>
#include <cmath>
using namespace std;

class Polar;

//====================================================
class Rectangle
{
  float length, bredth;
public:
  Rectangle(){}
  Rectangle(float ,float);

  operator Polar();

  int getLength(){return(length);}
  int getBredth(){return(bredth);}
  void putLength(float x){length = x;}
  void putBredth(float y){bredth = y;}

  void putData(){cout<<"Length : "<<length<<"\tBreadth : "<<bredth<<endl;}
  ~Rectangle(){}
};


//====================================================

class Polar{
  float angle, rad;
public:

  Polar(){}
  Polar(float , float);

  operator Rectangle();

  int getAngle(){return(angle);}
  int getRadius(){return(rad);}
  void putAngle(float a){angle=a;}
  void putRadius(float r){rad = r;}

  void putData(){cout<<"Angle : "<<angle<<"\tRadius : "<<rad<<endl;}
  ~Polar(){}
};

//===========================================================
Rectangle::Rectangle(float x, float y)
{
  length = x;
  bredth = y;
}

Rectangle::operator Polar()
{
  Polar temp;
  float a = atan2(bredth, length), r = sqrt(length*length + bredth*bredth);
  temp.putAngle(a);
  temp.putRadius(r);

  return(temp);
}

//===========================================================
Polar::Polar(float x, float y)
{
  angle = x;
  rad = y;
}
Polar::operator Rectangle()
{
  Rectangle temp;
  float l = rad*cos(angle), b =rad*sin(angle);
  temp.putLength(l);
  temp.putBredth(b);
  return(temp);
}

//===========================================================
int main()
{
  float radians = 120 * M_PI / 180; // convert to radians

  // roundtrip polar->rectangle->polar
  Polar p1(radians, 25);
  p1.putData();

  Rectangle r1 = p1;
  r1.putData();

  Polar p2 = r1;
  p2.putData();

  return 0;
}

Quote:

So basically i want to add 2 matrix object and assign the result to the third non-initiated matrix object, without changing the values of first 2 original matrix.

Quote:

Enter matrix elements row by row

m[0][0] = 1
m[0][1] = 2
m[1][0] = 3
m[1][1] = 4
m[2][0] = 5
m[2][1] = 6


1 2
3 4
5 6
m[0][0] = 7
m[0][1] = 8
m[1][0] = 9
m[1][1] = 10
m[2][0] = 11
m[2][1] = 12


7 8
9 10
11 12




8 10 47120720 0 0 0 0 0 0 0 50331651 41272 47127056 0 47120720 0 0 2396 136 0
12 14 47120720 0 1550742898 1148219457 1549890657 1633906508 1700027500
1426092141 1146242387 1229016399 1162100046 1330924371 1429482832 844253517 1398079566 1329877573 1313423693 1095717471
16 18 47120720 0 1162690894 1918981181 1426091637 1347568979 1229344594
1128088908 1934974010 1551069797 1970430292 1398145134 1127232561 1414417743 1397509967 1547322173 1735357008 544039282
47120720 0 47127424 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0
47120720 0 47127424 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0
47120720 0 47127424 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0
47120720 0 47127424 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0
47120720 0 47127424 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0
47120720 0 47127424 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0
47120720 0 47127424 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0
47120720 0 47127424 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0
47120720 0 47127424 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0
47120720 0 47127424 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0
47120720 0 47127424 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0
47120720 0 47127424 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0
47120720 0 47127424 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0
47120720 0 47127424 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

#include <iostream>
using namespace std;

class matrix{
    int **p;                        //pointer to Matrix
    int d1, d2;
    int id=0;                        //identif which operator is used

public:
    //matrix(){}                      //default constructor
    matrix(int x=20, int y=20);       //parameterised

    //to pass private data-members to other objects
    int getD_1(){return (d1);}
    int getD_2(){return (d2);}
    //int getId(const int x){id =x ;}
    //void showId(){cout<<"ID :\t"<<id<<endl;}

    //for taking input nad printing output
    void get_element();
    void put_element();

    //to check feasibility
    friend int checkAdd(matrix &, matrix &);                                     //to check the feasibility of the operation
    friend int checkMul(matrix &, matrix &);

    //Rule of three
    friend matrix operator+(matrix &, matrix &);
    friend matrix operator*(matrix &, matrix &);
    //friend matrix operator-(matrix &, matrix &);

    void operator = (matrix );

    ~matrix(){
        for (int i = 0; i < d1; i++)
            delete p[i];
        delete p;
    }
};

//=================================================================================================================

//defining overloaded assingment operator
void matrix::operator = (matrix obj){
    this->d1 = obj.d1;
    this->d2 = obj.d2;
    this->id = obj.id;
    for(int i=0; i<d1; i++)
        for(int j=0; j<d2; j++)
            this->p[i][j] = obj.p[i][j];
}

//defining overloaded addition operator
matrix operator+(matrix &a, matrix &b){
    matrix temp;
    temp.d1 = a.d1;
    temp.d2 = a.d2;
    temp.id = 1;

    if(checkAdd(a, b) == 0){                //checks the viability if it's feasible or not.
        for(int i=0; i<temp.d1; i++)
            for(int j=0; j<temp.d2; j++)
                temp.p[i][j] = a.p[i][j] + b.p[i][j] ;

        return(temp);
    }
    else {
        cout<<"Matrix addition not possible as rows and coloumn's of given 2 matrices are not equal"<<endl;
        return(a);
    }
}

//defining overloaded Multiplication operator
matrix operator*(matrix &a, matrix &b){
    matrix temp;
    temp.d1 = a.d1;
    temp.d2 = b.d2;
    temp.id = 2;

    if(checkMul(a, b) == 0){              //checks the viability if it's feasible or not.
        int sum=0;
        for (int c = 0; c < a.d1; c++) {
            for (int d = 0; d < b.d2; d++) {
                for (int k = 0; k <b.d1; k++) {
                    sum = sum + a.p[c][k]*b.p[k][d];
                }
                temp.p[c][d] = sum;
                sum = 0;
            }
        }
        return (temp);
    }
    else {
        cout<<"Matrix Multiplication is not possible as coloumn of 1st Matrix != Row of 2nd Matrix "<<endl;
        return(a);
    }
}

//defining parameterised constucter
matrix ::matrix(int x, int y){
    d1 = x;
    d2 = y;
    p = new int *[d1];                  //creates an array of pointers

    for(int i=0; i<d1; i++)
        p[i] = new int [d2];            //creates row for each row
}

//defining checkAdd f^n to check if given 2 matrices obj can be added or not
int checkAdd(matrix &a, matrix &b){
    if(a.getD_1() == b.getD_1() && a.getD_2() == b.getD_2())
        return 0;
    else return 1;
}

//defining checkMul f^n to check if 2 matrices obj can be Multiplied.
int checkMul(matrix &a, matrix &b){
    if(a.getD_2() == b.getD_1())
        return 0;
    else return 1;
}

//gets the element from the user.
void matrix::get_element(){
    for(int i=0; i<d1; i++)
        for(int j=0; j<d2; j++){
            cout<<"m["<<(i+1)<<"]["<<(j+1)<<"] = ";
            cin>>p[i][j];
        }
}


//displays the current matrix
void matrix::put_element(){
    if(id == 1) cout<<"\nThe result of addition of 2 matrices is :"<<endl;
    else if(id==2)  cout<<"\nThe result of product of 2 matrices is:"<<endl;

    for(int i=0; i<d1; i++){
        for(int j=0; j<d2; j++){
            cout<<p[i][j]<<"\t";
        }
        cout<<endl;
    }
    cout<<"\n";
}

//=====================================================================================================================

int main(){
    matrix A(3, 2), B(2, 4), C;                     //matrix objects a constucted

    cout<<"Enter matrix elements row by row \n\n";
    A.get_element();
    A.put_element();

    B.get_element();
    B.put_element();

    C = A * B;
    C.showId();
    C.put_element();

    C = A + B;
    C.showId();
    C.put_element();

    return 0;
}

1. Use the existing I2C support on the Raspberry Pi with the I2C GPIO pins
   
2. Implement your own I2C support on general use GPIO pins
   

Quote:

all of the sample codes I have read so far are "limited" to open ioctl file and "write " to I2C slave address.

int fd = open("/dev/i2c-1", O_RDWR);
// Use I2C_SLAVE_FORCE if the device is in use (e.g. when a driver is installed)
ioctl(fd, I2C_SLAVE, addr);
read(fd, buffer, length);

dtoverlay=i2c-speed,i2c1_baudrate=400000

dtparam=i2c_vc=on

#include <bcm2835.h>  

int main(int argc, char **argv)  
{  
    char buf[1];

    if (!bcm2835_init())return 1;  
    bcm2835_i2c_begin();                //Start I2C operations.
    bcm2835_i2c_setSlaveAddress(0x20);  //I2C address
    bcm2835_i2c_set_baudrate(10000);    //1M baudrate

    while(1)  
    {   
        buf[0] = 0xEF;    //LED ON
        bcm2835_i2c_write(buf,1);
        bcm2835_delay(500);
        buf[0] = 0xFF;     //LED OFF
        bcm2835_i2c_write(buf,1);
        bcm2835_delay(500); 
    }    
    bcm2835_i2c_end();  
    bcm2835_close();  
    return 0;  
} 

DUMPBIN /SYMBOLS YourDLL.DLL > symbols.txt

#define GLfloat float	// No sure if you want floats or double you can change here
/* Calculate euclidian distance between vertex points (x1,y1) and (x2,y2) */
GLfloat GLDistance2D (GLfloat x1, GLfloat y1,						// Vertex 1 (x1,y1)
							GLfloat x2, GLfloat y2)					// Vertex 2 (x2,y2)
{
	GLfloat dx, dy;
	dx = x2 - x1;													// Diff x
	dy = y2 - y1;													// Diff y
	if ( dx < -FLT_EPSILON || dx > FLT_EPSILON ||
		 dy < -FLT_EPSILON || dy > FLT_EPSILON )					// Check dx, dy or both are non zero 
	{
		return sqrtf(dx * dx + dy * dy);							// Calculate the distance	
	}
	return (GLfloat) 0.0;											// Both dx and dy are zero
}


/* Given (px, py) and two points forming line segment(x1, y1), (x2, y2).
   Calculate the closest point(cpx, cpy) between the point and the line and
   return the distance.The linesegment flag is true the closest point must be
   on the line segment or false it does an extended infinite line test. */
GLfloat GLDistanceToLine2D (GLfloat px, GLfloat py,					// Test point (px,py)
							GLfloat x1, GLfloat y1,					// Line vertex 1 (x1,y1)
							GLfloat x2, GLfloat y2,					// Line vertex 2 (x2,y2)
							bool linesegment,						// Flag true if line segment, false extended line								
							GLfloat* cpx, GLfloat* cpy)			// Closest point point result pointers
{
	GLfloat u;														// see Paul Bourke's original article(s)
	GLfloat dx = x2 - x1;											// Diff x
	GLfloat dy = y2 - y1;											// Diff y
	GLfloat SqLineMag = dx * dx + dy * dy;							// Square of line magnitude
	if (SqLineMag > -FLT_EPSILON && SqLineMag < FLT_EPSILON) {		// We have a single point there is no measurable distance between vertexes 
		if (linesegment) return GLDistance2D(px, py, x1, y1);		// Line segement test return distance between 2 pts
		 else return (GLfloat)-1.0;									// Extended line invalid return -1 as it's impossible
	}
	u = ((px - x1)* dx + (py - y1)* dy) / SqLineMag;				// Calculate value u											
	if ((linesegment) && ((u < FLT_EPSILON) || (u > (GLfloat)1.0)))	// Line segment test and closest point is outside the segment
	{
		GLfloat ix, iy;
		ix = GLDistance2D(px, py, x1, y1);							// Distance line point (x1,y1) to point (px,py)
		iy = GLDistance2D(px, py, x2, y2);							// Distance line point (x2,y2) to point (px,py)
		if (ix < iy) {												// If first distance less than second												
			if (cpx) (*cpx) = x1;									// If x intersect result needed return x1
			if (cpy) (*cpy) = y1;									// If y intersect result needed return y1
			return(ix);												// Return distance as calculated distance ix
		}
		else {
			if (cpx) (*cpx) = x2;									// If x intersect result needed return x2
			if (cpy) (*cpy) = y2;									// If y intersect result needed return y2
			return(iy);												// Return distance as calculated distance iy
		}
	}
	else {															// Closest point is between line points or extended line test	
		GLfloat ix, iy;
		ix = x1 + (u * dx);											// Calculate intersection point x
		if (cpx) (*cpx) = ix;										// If x intersect result needed return it
		iy = y1 + (u * dy);											// Calculate intersection point y
		if (cpy) (*cpy) = iy;										// If y intersect result needed return it
		return GLDistance2D(px, py, ix, iy);						// Return the distance
	}
}

GLfloat ix, iy;
GLfloat dist = GLDistanceToLine2D(100, 100, 200, 0, 200, 200, true, &ix, &iy);