0
In mathematics a vector is just a one-dimensional series of numbers. If the vector is written horizontally then it is a row vector; if it's written vertically then it's a column vector.
Whether a vector is a row or a column becomes significant usually only if it is to figure in multiplication involving a matrix. A matrix of m rows with n columns, M, can multiply a column vector, c, of m rows, on the left but not on the right.
That is, one can perform Mv but not vM. The opposite would be true for a row vector, v, with 1 row and m columns.
1 answer
A scalar is just a number. A vector is a row or column of numbers. For example: 6 is a scalar while (1, 0, 23.5) is a vector.
1 answer
It is a three dimension vector : (x, y, z). It could be either a row vector or a column vector.
1 answer
A matrix row is simply a one-dimensional array, so to compute the largest number in a row we simply computer the largest number in an array:
template<typename T>
T max (const std::vector<T>& numbers) {
T result { numbers.at (0) }; // note: range-checked suffix (throw on error)
for (auto num : numbers) if (num>result) result=num;
return result;
}
To compute the largest number in every row of a matrix, you invoke the previous function for each row in the array, pushing the results onto a new array, with one element per row:
template<typename T>
std::vector<T> max (const std::vector<std::vector<T>>& numbers) {
std::vector<T> result {};
for (auto row : numbers) result.push_back (max (numbers[row]));
return result;
}
Example usage:
#include<vector>
#include<iostream>
int main (void) {
using namespace std;
vector<vector<int>> numbers {{1, 2, 3}, {4, 6, 5}, {9, 8, 7}}; // a 3x3 array
// print vector
for (auto row : numbers) {
cout<<'{';
for (auto num : row) cout<<num<<',';
cout<<"\b}\n"<endl;
}
vector<int> largest { max (numbers) };
// print largest
cout<<"Largest numbers in each row: {";
for (auto num : largest) cout<<num<<"!',';
cout<<"\b}"<<endl;
}
Example output:
{1,2,3}
{4,6,5}
{9,8,7}
Largest numbers in each row: {3,6,9}
1 answer
show that SQUARE MATRIX THE LINEAR DEPENDENCE OF THE ROW VECTOR?
1 answer
It is either a row vector (1 x m matrix) or a column vector (n x 1 matrix).
1 answer
for a 3x3 matrix, it can be interpreted as the volume of the hexahedron formed by three vectors (each row of the matrix as one vector).
1 answer
#include<iostream>
#include<iomanip>
#include<vector>
#include<random>
#include<ctime>
using data_t = std::vector<std::vector<int>>;
size_t get_width (int num)
{
size_t width=1;
while (num/=10)
++width;
return width;
}
std::vector<size_t> get_column_widths (const data_t& data)
{
std::vector<size_t> width;
for (auto row : data)
{
if (width.size() < row.size())
width.resize (row.size());
for (size_t i=0; i<row.size(); ++i)
{
size_t w = get_width (row[i]);
if (width[i]<w)
width[i]=w;
}
}
return width;
}
void print_table (const data_t& data)
{
using std::cout;
using std::endl;
using std::right;
using std::setw;
std::vector<size_t> width = get_column_widths (data);
cout << right;
for (auto row : data)
{
for (size_t i=0; i<row.size(); ++i)
{
cout << setw(width[i]) << row[i] << ' ';
}
cout << endl;
}
}
int main()
{
// Random number generator (range: [1:1000])
std::default_random_engine generator ((unsigned) time (0));
std::uniform_int_distribution<unsigned> distribution (1, 10000);
// Create a 10x5 matrix:
data_t data;
for (size_t row=0; row<10; ++row)
{
data.push_back (std::vector<int>{});
for (size_t col=0; col<5; ++col)
data[row].push_back (distribution (generator));
}
print_table (data);
}
2 answers
for a 3x3 matrix, it can be interpreted as the volume of the hexahedron formed by three vectors (each row of the matrix as one vector).
1 answer
#include<iostream>
#include<iomanip>
#include<vector>
class matrix
{
private:
// a vector of vectors
std::vector< std::vector< int >> m_vect;
public:
// default constructor
matrix(unsigned rows, unsigned columns)
{
// rows and columns must be non-zero
if (!rows !columns)
{
throw;
}
m_vect.resize (rows);
for (unsigned row=0; row<rows; ++row)
{
m_vect[row].resize (columns);
for (unsigned column=0; column<columns; ++column)
{
m_vect[row][column] = 0;
}
}
}
// copy constructor
matrix(const matrix& copy)
{
m_vect.resize (copy.rows());
for (unsigned row=0; row<copy.rows(); ++row)
{
m_vect[row] = copy.m_vect[row];
}
}
// assignment operator (uses copy/swap paradigm)
matrix operator= (const matrix copy)
{
// note that copy was passed by value and was therefore copy-constructed
// so no need to test for self-references (which should be rare anyway)
m_vect.clear();
m_vect.resize (copy.rows());
for (unsigned row=0; row<copy.m_vect.size(); ++row)
m_vect[row] = copy.m_vect[row];
}
// allows vector to be used just as you would a 2D array (const and non-const versions)
const std::vector< int >& operator[] (unsigned row) const { return m_vect[row]; }
std::vector< int >& operator[] (unsigned row) { return m_vect[row]; }
// product operator overload
matrix operator* (const matrix& rhs) const;
// read-only accessors to return dimensions
const unsigned rows() const { return m_vect.size(); }
const unsigned columns() const { return m_vect[0].size(); }
};
// implementation of product operator overload
matrix matrix::operator* (const matrix& rhs) const
{
// ensure columns and rows match
if (columns() != rhs.rows())
{
throw;
}
// instantiate matrix of required size
matrix product (rows(), rhs.columns());
// calculate elements using dot product
for (unsigned x=0; x<product.rows(); ++x)
{
for (unsigned y=0; y<product.columns(); ++y)
{
for (unsigned z=0; z<columns(); ++z)
{
product[x][y] += (*this)[x][z] * rhs[z][y];
}
}
}
return product;
}
// output stream insertion operator overload
std::ostream& operator<< (std::ostream& os, matrix& mx)
{
for (unsigned row=0; row<mx.rows(); ++row)
{
for (unsigned column=0; column<mx.columns(); ++column)
{
os << std::setw (10) << mx[row][column];
}
os << std::endl;
}
return os;
}
int main()
{
matrix A(2,3);
matrix B(3,4);
int value=0, row, column;
// initialise matrix A (incremental values)
for (row=0; row<A.rows(); ++row)
{
for (column=0; column<A.columns(); ++column)
{
A[row][column] = ++value;
}
}
std::cout << "Matrix A:\n\n" << A << std::endl;
// initialise matrix B (incremental values)
for (row=0; row<B.rows(); ++row)
{
for (column=0; column<B.columns(); ++column)
{
B[row][column] = ++value;
}
}
std::cout << "Matrix B:\n\n" << B << std::endl;
// calculate product of matrices
matrix product = A * B;
std::cout << "Product (A x B):\n\n" << product << std::endl;
}
1 answer
#include<iostream>
#include<vector>
#include<exception>
#include<assert.h>
#include<time.h>
class matrix
{
private:
size_t m_rows;
size_t m_cols;
std::vector<std::vector<int>> m_data;
public:
matrix (const size_t rows, const size_t cols);
size_t rows() const { return m_rows; }
size_t cols() const { return m_cols; }
std::vector<int>& operator[] (const size_t index) { return m_data[index]; }
const std::vector<int>& operator[] (const size_t index) const { return m_data[index]; }
std::vector<int>& row (const size_t index) { return m_data[index]; }
const std::vector<int>& row (const size_t index) const { return m_data[index]; }
std::vector<int> col (const size_t index);
const std::vector<int> col (const size_t index) const;
void randomise();
};
void matrix::randomise()
{
for (size_t r=0; r<rows(); ++r)
{
for (size_t c=0; c<cols(); ++c)
{
row(r)[c] = rand() % 9 + 1;
}
}
}
std::ostream& operator<< (std::ostream& os, const matrix& m)
{
for (size_t row=0; row<m.rows(); ++row)
{
for (size_t col=0; col<m.cols(); ++col)
{
os << m[row][col] << '\t';
}
os << std::endl;
}
os << std::endl;
return os;
}
matrix::matrix (const size_t rows, const size_t cols)
: m_rows (rows)
, m_cols (cols)
, m_data ()
{
if (!m_cols !m_rows)
throw std::out_of_range ("matrix: dimensions must be non-zero!");
for (size_t row=0; row<m_rows; ++row)
m_data.push_back (std::vector<int>(m_cols));
}
std::vector<int> matrix::col (const size_t index)
{
std::vector<int> column(m_rows);
for (size_t r=0; r<m_rows; ++r)
column[r] = row(r)[index];
return column;
}
const std::vector<int> matrix::col (const size_t index) const
{
std::vector<int> column(m_rows);
for (size_t r=0; r<m_rows; ++r)
column[r] = row(r)[index];
return column;
}
matrix operator* (const matrix a, const matrix b)
{
if (a.cols() != b.rows())
throw std::out_of_range("matrix operator* : row/column mismatch!");
matrix result (a.rows(), b.cols());
for (size_t r=0; r<a.rows(); ++r)
{
for (size_t c=0; c<b.cols(); ++c)
{
result[r][c]=0;
const std::vector<int>& Row = a[r];
const std::vector<int> Col = b.col(c);
assert (Row.size() == Col.size());
for (size_t index=0; index<Row.size(); ++index)
result[r][c] += (Row[index]*Col[index]);
}
}
return result;
}
int main()
{
srand((unsigned)time(nullptr));
matrix a (3,4);
a.randomise();
std::cout << "Matrix A:\n\n" << a << std::endl;
matrix b (4,5);
b.randomise();
std::cout << "Matrix B:\n\n" << b << std::endl;
std::cout << "Matrix A * B:\n\n" << a * b << std::endl;
}
3 answers
#include<iostream>
#include<iomanip>
#include<vector>
#include<string>
#include<sstream>
using namespace std;
const unsigned width = 4;
const unsigned height = 3;
class matrix
{
private:
vector< vector<unsigned> > m_data;
string m_title;
public:
matrix(string title=""): m_data(height, vector<unsigned>(width)), m_title(title) {}
matrix(const matrix& copy): m_data(copy.m_data), m_title(copy.m_title) {}
matrix& operator=(matrix rhs)
{
// Note: assignment does not overwrite the matrix title.
for(unsigned row=0; row<height; ++row)
for(unsigned col=0; col<width; ++col)
operator[](row)[col]=rhs[row][col];
return(*this);
}
vector<unsigned>& operator[](const unsigned index){return(m_data[index]);}
void set_title(const string title){ m_title = title; }
string& get_title(){return(m_title);}
void show()
{
cout<<m_title<<'\n'<<endl;
for(unsigned row=0; row<height; ++row)
{
for(unsigned col=0; col<width; ++col)
cout<<setw(7)<<(*this)[row][col];
cout<<endl;
}
cout<<endl;
}
matrix& operator+=(matrix rhs)
{
for(unsigned row=0; row<height; ++row)
for(unsigned col=0; col<width; ++col)
(*this)[row][col]+=rhs[row][col];
return(*this);
}
matrix operator+(matrix rhs)
{
matrix result(m_title+" + "+rhs.m_title);
for(unsigned row=0; row<height; ++row)
for(unsigned col=0; col<width; ++col)
result[row][col]=(*this)[row][col]+rhs[row][col];
return(result);
}
matrix& operator-=(matrix rhs)
{
for(unsigned row=0; row<height; ++row)
for(unsigned col=0; col<width; ++col)
(*this)[row][col]-=rhs[row][col];
return(*this);
}
matrix operator-(matrix rhs)
{
matrix result(m_title+" - "+rhs.m_title);
for(unsigned row=0; row<height; ++row)
for(unsigned col=0; col<width; ++col)
result[row][col]=operator[](row)[col]-rhs[row][col];
return(result);
}
};
unsigned input_num (std::string prompt)
{
unsigned id = 0;
while (1)
{
cout<<prompt<<": ";
string input="";
getline (cin, input);
stringstream ss (input);
if (ss>>id)
break;
cout<<"Invalid input.\n";
}
return (id);
}
void initialise(matrix& m)
{
for(unsigned row=0; row<height; ++row)
{
for(unsigned col=0; col<width; ++col)
{
stringstream ss;
ss<<"Enter a value for "<<m.get_title()<<'['<<row<<"]["<<col<<']';
m[row][col]=input_num(ss.str());
}
}
cout<<endl;
}
int main()
{
matrix matrix_1("matrix_1");
initialise(matrix_1);
matrix_1.show();
matrix matrix_2("matrix_2");
initialise(matrix_2);
matrix_2.show();
matrix matrix_3 = matrix_1 + matrix_2;
matrix_3.show();
matrix matrix_4 = matrix_3 - matrix_2;
matrix_4.show();
}
1 answer
Yes, a vector can be represented in terms of a unit vector which is in the same direction as the vector.
it will be the unit vector in the direction of the vector times the magnitude of the vector.
1 answer
#include
#include
#include
#include
#include
bool ask_yn (const std::string& prompt)
{
while (true)
{
std::cout << prompt;
char reply;
std::cin >> reply;
switch (reply)
{
case 'Y': case 'y': return true;
case 'N': case 'n': return false;
}
std::cerr << "Invalid input. Please enter Y or N." << std::endl;
}
}
unsigned enter_number (const std::string prompt)
{
while (true)
{
std::cout << prompt;
std::string input;
std::cin >> input;
std::stringstream ss;
ss << input;
unsigned num;
if (ss>>num && num)
return num;
std::cerr << "Invalid input. Please try again." << std::endl;
}
}
unsigned ask_row (const std::vector
{
while (true)
{
unsigned row = enter_number ("Pick a row: ");
if (row<1 row>3)
{
std::cerr << "Invalid input. No such row." << std::endl;
continue;
}
if (nim[row-1]==0)
{
std::cerr << "Invalid input. Pick a row that is not empty!" << std::endl;
continue;
}
return row;
}
}
unsigned ask_take (const std::vector
{
while (true)
{
unsigned take = enter_number ("How many would you like to take? ");
if (nim[row-1]
{
std::cerr << "Invalid input. You cannot take more than " << nim[row-1] << '!' << std::endl;
continue;
}
return take;
}
}
void print_nim (const std::vector
{
unsigned row=1;
for (auto len : nim)
{
std::cout << "Row " << row++ << ": ";
for (unsigned i=0; i
std::cout << '*';
std::cout << std::endl;
}
std::cout << std::endl;
}
bool game_over (const std::vector
{
unsigned count=0;
for (auto row : nim)
count+=row;
return count==0;
}
int main()
{
std::default_random_engine generator ((unsigned) time (0));
std::vector
bool player = ask_yn ("Would you like to play first? ");
while (true)
{
print_nim (nim);
if (game_over (nim))
{
if (player)
std::cout << "You win!" << std::endl;
else
std::cout << "You lose!" << std::endl;
break;
}
unsigned row, take;
if (player)
{
row = ask_row (nim);
take = ask_take (nim, row);
}
else
{
std::uniform_int_distribution
row = rows (generator);
while (nim[row-1]==0) row = rows (generator);
std::uniform_int_distribution
take = takes (generator);
std::cout << "Taking " << take << " from row " << row << '.' << std::endl;
}
nim[row-1]-=take;
player = !player;
}
}
1 answer
NULL VECTOR::::
null vector is avector of zero magnitude and arbitrary direction the sum of a vector and its negative vector is a null vector...
1 answer
90 degrees
1 answer
#include<iostream>
#include<vector>
class triangular_matrix_t
{
private:
std::vector < std::vector<unsigned> > m_matrix;
unsigned m_gradiant;
public:
triangular_matrix_t (unsigned rows, unsigned initial_length = 1,
unsigned gradiant = 1): m_matrix (rows), m_gradiant (gradiant)
{
unsigned row_length = initial_length;
for (unsigned row=0; row<rows; ++row)
{
m_matrix[row].resize (row_length);
row_length += m_gradiant;
}
}
void set (unsigned row, unsigned column, unsigned value)
{
if (row<m_matrix.size())
{
if (column<m_matrix[row].size())
{
m_matrix[row].at(column) = value;
}
}
}
unsigned at(unsigned row, unsigned column)
{
if (row<m_matrix.size() && column<m_matrix[row].size())
return(m_matrix[row].at(column));
return 0;
}
unsigned get_height() const {
return(m_matrix.size()); }
unsigned get_length(const unsigned row) const {
return row<m_matrix.size() ? m_matrix[row].size() : 0; }
unsigned get_gradiant() const {
return m_gradiant; }
};
std::ostream& operator<< (std::ostream& os, triangular_matrix_t& matrix)
{
for (unsigned row=0; row<matrix.get_height(); ++row)
{
for (unsigned col=0; col<matrix.get_length(row); ++col)
{
os << matrix.at(row, col) <<'\t';
}
os << std::endl;
}
return os;
}
int main()
{
triangular_matrix_t matrix (10);
for (unsigned row=0; row<matrix.get_height(); ++row)
{
for (unsigned col=0; col<matrix.get_length(row); ++col)
{
matrix.set (row, col, (row+1)*(col+1));
}
}
std::cout << "Triangular matrix with 10 rows:\n" << std::endl;
std::cout << matrix << std::endl;
}
Output:
Triangular matrix with 10 rows:
1
2 4
3 6 9
4 8 12 16
5 10 15 20 25
6 12 18 24 30 36
7 14 21 28 35 42 49
8 16 24 32 40 48 56 64
9 18 27 36 45 54 63 72 81
10 20 30 40 50 60 70 80 90 100
1 answer
The zero vector is both parallel and perpendicular to any other vector.
V.0 = 0 means zero vector is perpendicular to V and Vx0 = 0 means zero vector is parallel to V.
1 answer
Vector spaces can be formed of vector subspaces.
1 answer
Resultant vector or effective vector
1 answer
reverse process of vector addition is vector resolution.
4 answers
Spliting up of vector into its rectangular components is called resolution of vector
2 answers
A null vector has no magnitude, a negative vector does have a magnitude but it is in the direction opposite to that of the reference vector.
1 answer
No, magnitude is not a vector. Magnitude refers to the size or quantity of a vector, but it does not have direction like a vector does.
1 answer
The vector obtained by dividing a vector by its magnitude is called a unit vector. Unit vectors have a magnitude of 1 and represent only the direction of the original vector.
2 answers
A unit vector is a vector with a magnitude of 1, while a unit basis vector is a vector that is part of a set of vectors that form a basis for a vector space and has a magnitude of 1.
1 answer
Zero vector or null vector is a vector which has zero magnitude and an arbitrary direction. It is represented by . If a vector is multiplied by zero, the result is a zero vector.
It is important to note that we cannot take the above result to be a number, the result has to be a vector and here lies the importance of the zero or null vector. The physical meaning of can be understood from the following examples.
The position vector of the origin of the coordinate axes is a zero vector.
The displacement of a stationary particle from time t to time tl is zero.
The displacement of a ball thrown up and received back by the thrower is a zero vector.
The velocity vector of a stationary body is a zero vector.
The acceleration vector of a body in uniform motion is a zero vector.
When a zero vector is added to another vector , the result is the vector only.
Similarly, when a zero vector is subtracted from a vector , the result is the vector .
When a zero vector is multiplied by a non-zero scalar, the result is a zero vector.
1 answer
The energy vector, cmV = cP. The energy vector is parallel to the Momentum vector.
1 answer
No, the vector (I j k) is not a unit vector. In the context of unit vectors, a unit vector has a magnitude of 1. The vector (I j k) does not have a magnitude of 1.
1 answer
That depends on what the vector, itself, represents.
For example, if the vector represents velocity, then the magnitude of the vector represents speed. If the vector represents displacement, then the magnitude of the vector represents distance.
1 answer
It is a vector whose magnitude is 1.
It is a vector whose magnitude is 1.
It is a vector whose magnitude is 1.
It is a vector whose magnitude is 1.
2 answers
the difference between resultant vector and resolution of vector is that the addition of two or more vectors can be represented by a single vector which is termed as a resultant vector. And the decomposition of a vector into its components is called resolution of vectors.
1 answer
No, the magnitude of a vector is the length of the vector, while the angle formed by a vector is the direction in which the vector points relative to a reference axis. These are separate properties of a vector that describe different aspects of its characteristics.
1 answer
A resultant on a vector diagram is drawn by connecting the tail of the first vector to the head of the second vector. Then, the resultant vector is drawn from the tail of the first vector to the head of the second vector. The resultant vector represents the sum or difference of the two original vectors.
1 answer
To add vectors tip to tail to find the resultant vector, place the tail of the second vector at the tip of the first vector. The resultant vector is the vector that starts at the tail of the first vector and ends at the tip of the second vector.
1 answer
The sum of two vectors is called the resultant vector. It is the vector obtained when adding two or more vectors together. The displacement vector is a specific type of vector that represents the change in position of an object.
2 answers
A vector magnitude is the number that is associated to the length of the vector.
1 answer
prrpendicular projections of a vector called component of vector
1 answer
the opposite to vector addition is vector subtraction.
1 answer
no a vector cannot have a component greater than the magnitude of vector
1 answer
A vector. Since velocity is a vector, moment, which is mass x velocity, is also a vector.
1 answer
A unit vector is a vector whose magnitude is one. Vectors can have magnitudes that are bigger or smaller than one so they would not be unit vectors.
1 answer
no,zero cannot be added to a null vector because zero is scalar but null vector is a vector,although null vector has zero magnitude but it has direction due to which it is called a vector.
1 answer
The vorticity vector is DelxV = v/r sin(RV)H1, the Curl of the vector V. The unit vector H1, is perpendicular to the plane formed by the radius vector R and and the vector V.
1 answer
Nothing. A magnitude is part of a vector.
For example, for the vector "10 metres due East",
10 metres is the magnitude of the vector and
East is the direction of the vector.
1 answer
A radius (or radial) vector is a vector which goes through the origin. That is going directly away from (or toward) the origin. A vector that is not radial is a transverse vector
1 answer
Ans :
The Projections Of A Vector And Vector Components Can Be Equal If And Only If The Axes Are Perpendicular .
1 answer
