Linear Algebra

The answer to this is 350cm. This is because 1 meter is 100 cm. So you must multiply 3.5 by 100 which gives you 350cm. Good luck! ;)

A linear expression can only have a numeric factor that can be "taken out".

The expression will be of the form ax + b where a and b are numbers that have k as their highest common factor (HCF).

That is, a = k*c

and b = k*d

Than being the case, ax + b = kcx + kd = k*(cx + d)

a positive answer

I accidently do not finish the equation part. I will put it up

If in the form of an equation, it has a variable with a power other than 0 or 1.

If in the form of a graph, it is not a straight line.

You have to multiply either one of the equations, or both of them by one, or two different positive or negative numbers, to manipulate the equation so that you can eliminate one of the variables. Ex: 4x-3y=2 / 2x-3y=2 ... You would have to multiply either the top or bottom equation by negative 1 to change one of the -3y's into positive 3y, then you can eliminate the y.

well,both are different methods but the answers are same.

more than a half

Another, simpler way of writing this would be: 4x + 3x - 7 x 2 + 6

To start, using order of operations, you would do 7 x 2 which equals 14.

So now you've got 4x + 3x - 14 + 6.

Because different terms are being used, we collect like terms.

First is 4x + 3x which equals 7x.

Then there's 14 + 6 BUT because before the 14 there is a minus sign, it becomes NEGATIVE 14. It should now look like -14 + 6 which equals -8.

Now the entire equation should look like 7x - 8.

I have simplified the equation, but you are in fact unable to factorise it because there are no common factors of 7 and 8.

A translation.

People who purchase the same product from the same store or manufacturer have built up a product image of what to expect each time they make a purchase. That's what gives a product meaning and value. Manufacturers should bear that in mind and ensure their products' quality standards as well as make sure they run the right advertising campaigns when making significant changes in their stuff to avoid losing customers. Also, this is how closely related the various product lines are in the end use

No, it is not.

48

The historic cost concept is an extension of the money measurement rule. It requires transactions to be recorded at the "original" cost. The changes in prices or values will be ignored.

Cell phone companies

You probably do mean "100" and not hundredth, since the number is reported only to tenths. The answer must be 10,000. (Ten thousand).

Each step is nine less.

This question can be answered by using basic linear algebra. The two equations give are:

2x-6y=12

12x-3y=6

This can be used to set up a matrix equation of the form:

Ax=b

where x is a column vector of the form:

Row 1: x

Row 2: y

and b is a column vector of the form:

Row 1: 12

Row 2: 6

A is a 2 x 2 matrix containing the coefficients of x and y in the two equations:

Row 1: 2, 6

Row 2: 12, 3

This single matrix equation is thereby equivalent to the initial system of equations. If we could manipulate this matrix equation to yield an "A" matrix of the form:

Row 1: 1, 0

Row 2: 0, 1

we are effectively saying 1 x = something in the "b" matrix, and 1 y = something else in the "b" matrix. We could also conceivably end up with something such as:

Row 1: 1, 0

Row 2: 0, 0

which, depending on what remains in the "b" matrix after our manipulations, could mean no solution exists or could mean that there are an infinite number of solutions. Let's start by creating what is called an "augmented matrix" that contains the coefficients of x and y stored in A and the numerical constants stored in b.

[2, -6 | 12]

[12, -3 | 6]

In this notation, a pipe ( | ) is used to separate the "A" matrix elements from the "b" matrix elements. The first row of this augmented matrix can be read across as "2x + -6y = 12", essentially condensing the first equation. The remaining rows can be read in the same fashion. If more equations were being considered, more rows would exist, and if more variable were being considered, more columns would exist, but there is always only one column to the right of the pipe (that is to say the "b" vector is always a one-column vector).

Row operations can be performed to rewrite this matrix in a form called "reduced row echelon form" (RREF). A matrix in RREF has the leftmost element of each row as 1, and all row elements above and below this 1 as zero, with uppermost rows receiving priority. Visually:

[1, 0, 0, 0 | 5]

[0, 1, 0, 0 | 6]

[0, 0, 3, 4 | 4]

is in RREF, while:

[1, 0, 0, 0 | 3]

[0, 1, 4, 3 | 2]

[2, 1, 0, 0 | 2]

is not in RREF. This is not a full explanation of RREF, but numerous online resources exist to more fully expand on this.

Three different row operations can be performed to keep a matrix "row equivalent" to itself. Row equivalency is key to solving this problem. The three row operations are:

1. Movement of entire rows (Row 1 can be switched with Row 2, for instance)

2. Scalar multiplication of rows (All elements of Row 1 can be multiplied individually by some scalar number)

3. Piecewise addition of rows (Column 1 element of Row 1 can be added to Column 1 element of Row 2 to form a new Row 2, leaving Row 1 unaffected)

Returning to the augmented matrix we are using in this problem:

[2, -6 | 12]

[12, -3 | 6]

To get this matrix into RREF, the following row operation sequence can be performed:

1/2 * Row 1:

[1, -3 | 6]

[12, -3 | 6]

-12 * Row 1 + Row 2:

[1, -3 | 6]

[0, 33 | -66]

1/33 * Row 2:

[1, -3 | 6]

[0, 1 | -2]

3 * Row 2 + Row 1:

[1, 0 | 0]

[0, 1 | -2]

This can be read as "1x + 0y = 0" and "0x + 1y = -2", meaning x=0 and y=-2 is the only solution to this system of equations. Meaning this system has only one solution. Graphically, if these two equations were plotted on in an x-y coordinate system, they would be two intersecting lines that intersect at one point. It is easy to see, however, that different lines could have caused different situations. If the two equations were of the same line, simply one lying on top of the other, there would be an infinite number of solutions. This would be represented in RREF by:

[1, 0 | c]

[0, 0 | 0]

where "c" is some number.

Also possible are parallel lines, meaning no solution exists since they never intersect. This would have been represented by:

[1, 0 | c]

[0, 0 | 1]

again, "c" is some number. The final row of such a matrix in RREF is stating an impossibility (0 = 1) and therefore no solution exists.

This same analysis can be extended to infinite numbers of equations with infinite numbers of variables.

It is not possible to "solve" b+815 because it is an expression - not an equation or inequality.

They are parallel lines.

If you mean: 3w2-26w+16 then it is (3w-2)(w-8) when factored

#include<stdio.h>

#include<math.h>

float detrm(float[][],float);

void cofact(float[][],float);

void trans(float[][],float[][],float);

main()

{

float a[25][25],k,d;

int i,j;

printf("ENTER THE ORDER OF THE MATRIX:\n");

scanf("%f",&k);

printf("ENTER THE ELEMENTS OF THE MATRIX:\n");

for(i=0;i<k;i++)

{

for(j=0;j<k;j++)

{

scanf("%f",&a[i][j]);

}

}

d=detrm(a,k);

printf("THE DETERMINANT IS=%f",d);

if(d==0)

printf("\nMATRIX IS NOT INVERSIBLE\n");

else

cofact(a,k);

}

/******************FUNCTION TO FIND THE DETERMINANT OF THE MATRIX************************/

float detrm(float a[25][25],float k)

{

float s=1,det=0,b[25][25];

int i,j,m,n,c;

if(k==1)

{

return(a[0][0]);

}

else

{

det=0;

for(c=0;c<k;c++)

{

m=0;

n=0;

for(i=0;i<k;i++)

{

for(j=0;j<k;j++)

{

b[i][j]=0;

if(i!=0&&j!=c)

{

b[m][n]=a[i][j];

if(n<(k-2))

n++;

else

{

n=0;

m++;

}

}

}

}

det=det+s*(a[0][c]*detrm(b,k-1));

s=-1*s;

}

}

return(det);

}

/*******************FUNCTION TO FIND COFACTOR*********************************/

void cofact(float num[25][25],float f)

{

float b[25][25],fac[25][25];

int p,q,m,n,i,j;

for(q=0;q<f;q++)

{

for(p=0;p<f;p++)

{

m=0;

n=0;

for(i=0;i<f;i++)

{

for(j=0;j<f;j++)

{

b[i][j]=0;

if(i!=q&&j!=p)

{

b[m][n]=num[i][j];

if(n<(f-2))

n++;

else

{

n=0;

m++;

}

}

}

}

fac[q][p]=pow(-1,q+p)*detrm(b,f-1);

}

}

trans(num,fac,f);

}

/*************FUNCTION TO FIND TRANSPOSE AND INVERSE OF A MATRIX**************************/

void trans(float num[25][25],float fac[25][25],float r)

{

int i,j;

float b[25][25],inv[25][25],d;

for(i=0;i<r;i++)

{

for(j=0;j<r;j++)

{

b[i][j]=fac[j][i];

}

}

d=detrm(num,r);

inv[i][j]=0;

for(i=0;i<r;i++)

{

for(j=0;j<r;j++)

{

inv[i][j]=b[i][j]/d;

}

}

printf("\nTHE INVERSE OF THE MATRIX:\n");

for(i=0;i<r;i++)

{

for(j=0;j<r;j++)

{

printf("\t%f",inv[i][j]);

}

printf("\n");

}

}

ALTERNATIVE CODE:

#include<iostream.h>

#include<stdio.h>

#include<conio.h>

#include<process.h>

#include<math.h>

// Written by Ran

// There have been enough comments to help the reader easily understand this program

// Helpfulness of COMMENTS in this program and Pre-requisites:-

// a. However it's assumed that the reader is familiar with the basics of C++

// b. It is also assumed that the reader knows the basic mathematics involving matrices.

// c. Since this program focusses on how to find inverse of a matrix, the comments

// in the program are sufficient for understanding this.

// It is assumed that the reader is familiar with basics of matrices in C++ (like input, display,

// addition,transpose,etc. of matrices)

// The comments in this program aim to explain the reader how to find inverse

// d. Hence through comments, the reader will also be taught how to find determinant,

// adjoint, cofactor,etc. However as said in the previous lines, there won't be comments

// for explaining basics like input,display,etc of a matrix using C++.

// NOTES:

// 1. float datatype has been used for matrix, determinant.

// 2. To have consistency between mathematics and C++, this program considers a[1][1] as the first element

// i.e row and column indices begin with 1 same as mathematics.

// Define a structure matrix with a matrix (2D array of type float) and size n

// Declare the objects of this structure used in this program

struct matrix

{

float a[25][25];

int n;

}obj,c_obj,trans_obj,obj_cof,obj_adj,obj_inv;

// Prototypes of the functions used in this program

void input(matrix&);

void display(matrix&);

matrix reduced(matrix &, int ,int );

float determinant(matrix);

float cofactor(matrix,int,int);

matrix transpose(matrix);

matrix adjoint(matrix);

matrix inverse(matrix obj);

// Begining of Main function

int main()

{

// Getting dimensions input by the user

int r,c;

again:

cout<<"Enter the order of the matrix: "<<endl;

cout<<"Enter Row dimension: ";

cin>>r;

cout<<"Enter Column dimension: ";

cin>>c;

// Check dimensions for square matrix so that inverse can be found

// If user enters different dimensions for row and column, ask to re-enter or quit program

if(r!=c)

{

char ans;

cout<<"Inverse can be found out only for a square matrix. Enter same dimension for row and column. Do you want to enter the dimensions again? Press Y for yes"<<endl;

cin>>ans;

if(ans=='y')

goto again;

else

cout<<"Program exit";

getch();

exit(0);

}

// If it's a square matrix, proceed

else if(r==c)

{obj.n=r;}

cout<<endl;

input(obj); // call input function to input the matrix elements from the user

display(obj); // display the matrix got as input now

// Following lines were used to test parts/sections/segments of the code and hence commented

/* char ans2;

cout<<"do u want to check reduce matrix? Press y to check reduce matrix and press any char to skip this"<<endl;

cin>>ans2;

if(ans2=='y')

{

int i,j;

cout<<"Enter row i and col j to get reduced matrix"<<endl;

cin>>i>>j;

// i=i-1;

// j=j-1;

c_obj=reduced(obj,i,j);

char ans1;

cout<<"Do you want to display the reduced matrix? If yes, Press y "<<endl;

cin>>ans1;

if(ans1=='y')

{

cout<<"Displaying reduced matrix..."<<endl;

display(c_obj);

}

}*/

//Find Determinant

cout<<"Finding determinant......"<<endl;

cout<<"The determinant is"<<determinant(obj)<<endl;

//Find Cofactor if user wishes to

char ans3;

cout<<"Do you want to find cofactor? Press y if yes"<<endl;

cin>>ans3;

while(ans3=='y')

{

int i,j;

cout<<"Finding cofactor. Enter row and column"<<endl;

cin>>i>>j;

cout<<"Cofactor of a["<<i<<"]["<<j<<"] is "<<cofactor(obj,i,j)<<endl;

cout<<"want of find cofactor of another element? Press y for yes"<<endl;

cin>>ans3;

}

// Following lines were to meant to test ONLY the transpose function and hence commented

/* cout<<"Printing Transpose of the matrix "<<endl;

matrix trans1;

trans1=transpose(obj);

display(trans1);

*/

// Find Inverse

cout<<"\n\n\n Finding Inverse. . .\n\n";

matrix obj_inv2;

obj_inv2=inverse(obj);

display(obj_inv2); // Display the matrix inverse

getch();

return 0;

}

void input(matrix &obj)

{

// This function gets elements of a matrix input by the user

// Parameter is the structure object obj (used throughout the program)

// Parameter is "passed by reference" so as to reflect the changes made by this function, to other functions that call it

cout<<"Enter the matrix "<<endl;

for (int i=1;i<=obj.n;i++)

{

for (int j=1;j<=obj.n;j++)

{

cout<<"Enter the element a["<<i<<"]["<<j<<"] : ";

cout<<endl;

cin>>obj.a[i][j];

}

}

}

void display(matrix &obj)

{

// This function displays elements of a matrix passed to it as a parameter

// Parameter is the structure object obj (used throughout the program)

// Parameter is "passed by reference" but may be "passed by value" also.

if(obj.n==0)

return;

else{

cout<<"The matrix is: "<<endl;

for (int i=1;i<=obj.n;i++)

{

for (int j=1;j<=obj.n;j++)

{

cout<<obj.a[i][j]<<" ";

}

cout<<endl;

}

}}

matrix reduced(matrix &obj, int i,int j)

{

// This function reduces the matrix passed as input to it

// The 'reduction' requirement is like this:

// Eliminate the row i and column j from the given matrix to get the reduced matrix

// This is done by the following logic:

// a is given matrix. c_obj is desired reduced matrix

// i. Using two for loops (iterating with p and q here) as usual, we scan the given matrix.

// row and col represent the current location pointer of row and column of the required reduced matrix.

// ii. All elements from given matrix are copied to reduced matrix except for those corresponding to

// row i and column j

// iii. The reduced matrix has its dimensions one less than that of given matrix

int row=1,col=1;

for(int p=1;p<=obj.n;p++) // outer loop traverses through rows as usual

{

for(int q=1;q<=obj.n;q++) // inner loop traverses through columns as usual

{

if((p!=i)&&(q!=j)) // Skip the elements corresponding to row i OR column j of the given matrix

{

c_obj.a[row][col]=obj.a[p][q];

col=col+1;

}

if(col>=obj.n) // When column 'col' of reduced matrix reaches (or exceeds n), reset it to 1

{ // and increment 'row'. This means current row of reduced matrix got filled and

// we need to begin filling a new row.

col=1;

row=row+1;

if (row>=obj.n) //This represents the case when both 'col' and 'row of reduce matrix reach (or

// exceed) n. This means the reduced matrix has been filled up.Break out of the loops.

break;

}

}

}

c_obj.n=obj.n-1; // Fix the dimension of the reduced matrix one less than the given input matrix

return c_obj; // Return the reduced matrix to the calling function.

}

float determinant(matrix obj)

{

// This function is called recursively until we get dimension = 1 where the only element in the matrix gets returned.

float det=0;

if(obj.n==1)

{return obj.a[1][1];

}

else

{

for(int scan=1;scan<=obj.n;scan++)//Fix the first row and vary the column in this row using for loop iteration variable 'scan'

{

det=det+obj.a[1][scan]*int(pow(-1,(1+scan)))*determinant(reduced(obj,1,scan));

// det is calculated to be the sum of the following

// i. prev value stored in det.

// ii. current element in the first row (i.e. a[1][scan]) MULTIPLIED by -1^(i+j) [i is 1 for 1st row and j is nothing but scan here MULTIPLIED by the reduced matrix corresponding to this i (1) and j (scan)

// PLEASE UNDERSTAND BY COMPARING THIS WITH THE MATHEMATICAL WAY OF CALCULATING DETERMINANT

// - It's computed in a similar way here.

}

return det;

}

}

float cofactor(matrix obj,int i,int j)

{

// The computation done here is like this:

// If the matrix (passed as paramenter) has dimension = 1, return the only element as cofactor

// Else, return determinant of the reduced matrix corresponding to i and j passed with a

// multiplication factor -1^(i+j)

float cofact;

if(obj.n==1)

{

return obj.a[1][1];

}

else

{

cofact=int(pow(-1,(i+j)))*determinant(reduced(obj,i,j));

}

return cofact;

}

matrix transpose(matrix obj)

{

// Transpose matrix is the given matrix with its rows and columns interchanged.

// Just invert the elements during storing when scanning through the for loops

// trans_obj is the transposed matrix, returned by the function.

// obj is the input matrix passed to this function.

trans_obj.n=obj.n;

for(int i=1;i<=obj.n;i++)

{

for(int j=1;j<=obj.n;j++)

{

trans_obj.a[i][j]=obj.a[j][i];

}

}

return trans_obj;

}

matrix adjoint(matrix obj)

{

// obj_adj is adjoint matrix and obj_cof is cofactor matrix

// both have dimensions n

// Cofactor matrix of a given matrix is a matrix whose elements are the cofactors of the respective

// elements of the given matrix

// Adjoint matrix is transpose of cofactor matrix. Return this

obj_adj.n=obj.n;

obj_cof.n=obj.n;

for(int i=1;i<=obj.n;i++)

{

for(int j=1;j<=obj.n;j++)

{

obj_cof.a[i][j]=cofactor(obj,i,j);

}

}

obj_adj=transpose(obj_cof);

return obj_adj;

}

matrix inverse(matrix obj)

{

// Formula : Inverse of a matrix is = adj(matrix)/its determinant

float d=determinant(obj); // First find determinant of the given matrix

matrix obj_null;

obj_null.n=0;

// Display error message if determinant is 0

if(d==0)

{

cout<<"Inverse can be found only if the determninant of the matrix is non-zero"<<endl;

return obj_null;

}

// Determinant is non-zero - Proceed finding inverse using the above formula

else

{

matrix obj_adj1=adjoint(obj);

obj_adj1.n=obj.n;

obj_inv.n=obj.n;

for(int i=1;i<=obj.n;i++)

{

for(int j=1;j<=obj.n;j++)

{

obj_inv.a[i][j]=(obj_adj1.a[i][j])/d;

}

}

return obj_inv;

}

}

Let me give you two examples:

One Variable: x * 5 + 2 = 5x + 2

Two Variables: x * 5 + y = 5x + y

If you find out what x is in the first example, you know the answer to the equation. Say x was 23, 23 * 5 + 2 = 117 .

If you find out what x is in the second example, you do not know the answer to the equation.

Say x was 23 again, 23 * 5 + y = 115 + y

You just end up with another equation.

Say y was 23 and you did not know what x was, x * 5 + 23 = 5x + 23

You end up with an equation.

So you have to know x AND y.

So say they were both 23, 23 * 5 + 23 = 138

That is the difference, with one variable, you need to know one variable to figure out the answer.

With two variables, you need to know both to know the answer.

Three variables, all three.

It goes on like that.

I hope I answered your question!

That would depend on the given system of linear equations which have not been given in the question