Chủ Nhật, 20 tháng 12, 2015

Inverse of a Matrix using Minors, Cofactors and Adjugate 3x3

We can calculate the Inverse of a Matrix by:
  • Step 1: calculating the Matrix of Minors,
  • Step 2: then turn that into the Matrix of Cofactors,
  • Step 3: then the Adjugate, and
  • Step 4: multiply that by 1/Determinant.
But it is best explained by working through an example!
Example: find the Inverse of A:
It needs 4 steps. It is all simple arithmetic but there is a lot of it, so try not to make a mistake!
Step 1: Matrix of Minors
The first step is to create a "Matrix of Minors". This step has the most calculations:
Determinant
For a 2×2 matrix (2 rows and 2 columns) the determinant is easy: ad-bc
Think of a cross:
  • Blue means positive (+ad),
  • Red means negative (-bc)
A Matrix
(It gets harder for a 3×3 matrix, etc)

The Calculations

Here are the first two, and last two, calculations of the "Matrix of Minors" (notice how I ignore the values in the current row and columns, and calculate the determinant using the remaining values):
And here is the calculation for the whole matrix:

Step 2: Matrix of Cofactors

This is easy! Just apply a "checkerboard" of minuses to the "Matrix of Minors". In other words, we need to change the sign of alternate cells, like this:

Step 3: Adjugate (also called Adjoint)

Now "Transpose" all elements of the previous matrix... in other words swap their positions over the diagonal (the diagonal stays the same):

Step 4: Multiply by 1/Determinant

Now find the determinant of the original matrix. This isn't too hard, because we already calculated the determinants of the smaller parts when we did "Matrix of Minors".
A Matrix
So: multiply the top row elements by their matching "minor" determinants:
Determinant = 3×2 - 0×2 + 2×2 = 10
And now multiply the Adjugate by 1/Determinant:
And we are done!

Thứ Ba, 15 tháng 12, 2015

Finding Eigenvector & Eigenvalue by using Jacobi algorithm

// NUMERICAL RECIPES in C
//http://www.library.cornell.edu/nr/bookcpdf/c11-1.pdf
//http://apps.nrbook.com/empanel/index.html#

#include <stdio.h>
#include <math.h>
#include <iostream>
using namespace std;

//Computes all eigenvalues and eigenvectors of a real symmetric matrix a[1..n][1..n].On
//output, elements of a above the diagonal are destroyed.d[1..n] returns the eigenvalues of a.
//v[1..n][1..n] is a matrix whose columns contain, on output, the normalized eigenvectors of
//a.nrot returns the number of Jacobi rotations that were required.

void Rotate(double a[4][4], double s, double tau, int i, int j, int k, int l)
{
double h, g;
g = a[i][j];
h = a[k][l];
a[i][j] = g - s * (h + g *tau);
a[k][l] = h + s * (g - h *tau);
}

bool Jacobi(double(&a)[4][4], double(&v)[4][4], double(&d)[4])
{
int n = 4;
int i, j, iq, ip;
double tresh, theta, tau, t, sm, s, h, g, c, b[4], z[4];

for (ip = 0; ip < n; ip++){
for (iq = 0; iq < n; iq++) v[ip][iq] = 0.0f;
v[ip][ip] = 1.0f;
}
for (ip = 0; ip < n; ip++){
b[ip] = d[ip] = a[ip][ip];
z[ip] = 0.0f;
}
for (i = 0; i < 50; i++){
sm = 0.0f;
for (ip = 0; ip < n - 1; ip++){
for (iq = ip + 1; iq < n; iq++)
sm += (double)fabs(a[ip][iq]);
}

if (sm == 0.0f)
return true;
if (i < 4)
tresh = 0.2f * sm / (n * n);
else
tresh = 0.0f;

for (ip = 0; ip < n - 1; ip++){
for (iq = ip + 1; iq < n; iq++){
g = 100.0f * (double)fabs(a[ip][iq]);
if (i > 4 && (fabs(d[ip]) + g) = = fabs (d[ip]) && (fabs(d[iq]) + g) = = fabs(d[iq])) a[ip][iq] = 0.0f;
else if (fabs(a[ip][iq]) > tresh){
h = d[iq] - d[ip];
if ((fabs(h) + g) == fabs(h)) t = a[ip][iq] / h;
else{
theta = 0.5f * h / a[ip][iq];
t = 1.0f / ((double)fabs(theta) + (double)sqrt(1.0f + theta * theta));
if (theta < 0.0f)    t = -t;
}
c = 1.0f / (double)sqrt(1 + t * t);
s = t * c;
tau = s / (1.0f + c);
h = t * a[ip][iq];
z[ip] -= h;
z[iq] += h;
d[ip] -= h;
d[iq] += h;
a[ip][iq] = 0.0f;

for (j = 0; j < ip; j++) Rotate(a, s, tau, j, ip, j, iq);
for (j = ip + 1; j < iq; j++) Rotate(a, s, tau, ip, j, j, iq);
for (j = iq + 1; j < n; j++) Rotate(a, s, tau, ip, j, iq, j);
for (j = 0; j < n; j++) Rotate(v, s, tau, j, ip, j, iq);
}
}
}
for (ip = 0; ip < n; ip++){
b[ip] += z[ip];
d[ip] = b[ip];
z[ip] = 0.0f;
}
}
return false;
}


//main function

double Q[4][4];
double Eigenvalue[4];
double Eigenvector[4][4];

Jacobi(Q, Eigenvector, Eigenvalue);

.....



Thứ Hai, 14 tháng 12, 2015

IELTS Writing- How To Write a Complex Sentence

Introduction
One of the biggest mistakes students make in IELTS writing is to try and show off and be overly ambitious with their grammar. This is because many students think that all of their sentences need to be ‘complex’ (they don’t!) and them not understanding what a ‘complex’ sentence is. Trying to write overly complicated sentences leads to grammar mistakes and this will lead to lost marks in many different areas.

This post will look at:
• how many ‘complex’ sentences you actually need in each paragraph
• what a ‘complex’ sentence actually is
• how to make complex sentences
• examples to help us understand and transfer this knowledge to our own writing

What does the examiner expect?
If we look at the examiners’ marking scheme it states that in order to get a band 6 for grammar we need to:
use a mix of simple and complex sentences.

For band 7 it states:
• Use a variety of complex structures.
This obviously means that we should use complex sentences in our writing, but it does not mean that we should try to make all of our sentences complex. All band 9 answers that I have seen use a mixture of both simple and complex sentences. The key is to know when to use them and we will look at this below. But first, we need to understand what a complex sentence actually is.

What is a complex sentence?
The main problem here seems to be the word ‘complex’. Complex, in this situation, does not mean complicated, long or impressive. This is a common misconception and leads to students writing very long and grammatically incorrect sentences that are very difficult to understand.

For example:
In the modern world, global warming is one of the most popular topics causing many environmental difficulties and tough challenges arising from its serious consequences.’

This is a very typical sentence from an essay that is trying to be overly complex. This student has tried to put four simple ideas in to one paragraph and the result is an awkward and incoherent sentence. They have lost control of the grammar and this affects the meaning. When meaning is affected it stops the reading understanding what is being said and that is really bad for you IELTS writing band scores.
Complex’ sentences are not actually very complex; they are just simple two or more simple sentences put together. Putting them together makes the essay more coherent and cohesive.

Let’s look at the first example again. In the sentence above there are four simple ideas that we can put in to simple sentences:
1. Global warming is a common topic these days.
2. Global warming causes environmental problems.
3. There are tough challenges associated with global warming.
4. Global warming has very serious consequences.

If we write all of our sentences in the IELTS exam like this we lose marks because they are too simple. What we need to do is put them together to make complex sentences.

Complex Sentence Examples
For example:
One of the most common environmental issues is global warming which causes many serious environmental problems. There are tough challenges associated with this issue and its effects have very serious consequences.

I don’t think there is anything ‘complex’ about these sentences, just simple ideas, simply put together.
‘Complex’ is just a label, not a description.
What I have done is take each of the four simple sentences and put them together in two complex sentences. This result is a grammatically correct, easy to understand paragraph.

When should I use complex sentences?
In general, we should use simple sentences when making main points; normally at the beginning of a paragraph. We should then use complex sentences when expanding on the main point, for instance when giving a supporting example or explaining your main point.

Example:
This is a question about whether ‘fast food’ or ‘junk food’ should be taxed at a higher rate than normal food.
Increasing taxes would raise prices and lower consumption. Fast food companies would pass on these taxes to consumers in the form of higher prices and this would lead to people not being able to afford junk food. For instance, the cost of organic food has proven prohibitively expensive for most people. Despite this, people in many developed countries, where the problem is most acute, can afford price hikes and will continue to eat high fat meals.

The first sentence is the ‘topic sentence’ and makes the main point. It is therefore acceptable for this to be a simple sentence.
The second sentence explains the main point and uses the word ‘and’ to link two simple sentences together, to make one complex sentence.
The third sentence gives an example and uses the linking phrase ‘for instance’. The final sentence makes a concession (shows the limitation of the argument) and is also a complex sentence, linking more than one idea together.
This paragraph has a mix of simple and complex sentences and therefore satisfies the marking criteria.

How do I make a complex sentence?
Remember that a complex sentence is just more than one simple sentence put together to make one sentence. We therefore need to learn and become confident using the various grammatical structures that allow us to do that. Below are a few ways we can link ideas together in a sentence.

To make a complex sentence we normally should have two things- a dependent clause and an independent clause. A clause is a group of words with both a subject and a verb.
An example of a dependent clauses is ‘….because the weather was cold.’ This is a dependent clause because it has a subject and a verb but it doesn’t make any sense on its own. To make sense we need to add an independent clause.
As the name suggests, an independent clause can make sense on its own. For example, ‘I wore a warm coat.’ If we combine these two clauses we get a complex sentence- ‘I wore a warm coat because the weather was cold.’

As you can see, ‘complex’ sentences don’t have to be complicated. Let’s now look at other ways we can make complex sentences.

1. Relative Clauses
You can use relative clauses to give essential or extra information about a person, place, or thing. This makes our writing more fluent and more coherent. We do this by using relative pronouns like who, which and that. For example, ‘He’s the kind of person who is always friendly.’

For example:
Air pollution can cause health problems. Air pollution is largely caused by motor vehicles.
We can convert these two simple sentences in to one complex sentences by using the word ‘which’.
Air pollution, which is mostly caused by motor vehicles, can cause health problems.

For example:
There is evidence that some people are more likely to smoke. These people have parents and friends who smoke.
We can link both of these sentences together by using the word ‘that’.
There is evidence that people who have parents and friends that smoke are more likely to smoke.

2. Subordinate Clauses
A subordinate clause can describe nouns and pronouns; describe verbs, adverbs, and adjectives; or act as the subject or object of another clause. They are made by connecting an independent clause with a dependent clause with words like as, because, while, until, even though, although, when and if.

3. Conditional Clauses
Also known as ‘If clauses’, they are used to express that the action in the main clause can only take place if a certain condition is met.

For example:
If I had a million dollars, I would quit my job.
I will be really happy, if I pass the IELTS test.
These clauses are good for giving examples in IELTS writing part 2.

For example:
‘Increasing taxes would raise prices and lower consumption. Fast food companies would pass on these taxes to consumers in the form of higher prices and this would lead to people not being able to afford junk food. If the cost of organic food proves prohibitively expensive for most people, they will simply not buy it. Despite this, people in many developed countries, where the problem is most acute, can afford price hikes and will continue to eat high fat meals.’

They are also useful for talking about unreal situations or to speculate about results in the past or present.
There are four different kinds of conditionals which I will outline below:

Zero Conditionals are used to talk about information that is true or facts. We can use if or when to introduce the conditional.
Example: Nowadays when we travel long distances, we usually use air travel.

First conditionals are used to talk about things in the present or future.
Example: If the city’s population continues to grow, we will need to build more infrastructure.

Second Conditionals are used to talk about things that are impossible.
Example: If the sun didn’t come up tomorrow, we wouldn’t have any life on earth.

Third Conditionals are used to speculate about past events. It is often used when we regret something or to imagine a past unreal situation.
Example: The Second World War would have never happened, if Germany had been given a fairer peace settlement in Word War One.

4. Compound Sentences
Compound sentences consist of two independent clauses linked together with a conjunction such as ‘and’, ‘for’ or ‘but’.
Examples:
I really want to study, but I’m too tired.
She got to the test centre early, and she did really well on her IELTS test.
Some students think these sentences are too simple to count as complex but they are wrong.

Warning
The crucial thing is to understand and be able to use these grammar structures before your IELTS test. Some students memorise lots of structures and try to insert them in to their essays without giving much thought to how they work or if they are accurate. This will only lead to unnatural and incoherent sentences. Remember that your sentences need to be also error free so only use structures you are confident using.
They key is to only use them appropriately. Concentrate on answering the question and if you know how to use these structures they will flow naturally.

Next Steps
I hope this post has demonstrated that you can write your ideas down in a clear and simple way and still satisfy the marking criteria for complex sentences.
When you are practicing IELTS writing questions try to think of what you want to say in simple sentences and then think of how these might be linked in to complex sentences. After enough practice it will become a natural thing to do and your writing will really improve.

http://ieltsadvantage.com/

Thứ Năm, 10 tháng 12, 2015

Read - write file.txt in C++

We have the located file with name:   c:/input_data/matrix.txt, data1.txt, data2.txt….
Ex:
matrix.txt:        m00 m01 m02
                        m10 m11 m12
                        m20 m21 m22
C++:
Read 1 file matrix.txt:
CMatrix intrinsic_matrix(4);                                           //create matrix 4x4

string datain_file = “c:/input_data/ matrix.txt”;                  //direction of file
string sline;
istringstream ssline;
ifstream matrix_file;

matrix_file.open(datain_file);
if (!matrix_file.data()){
            cout << " matrix_file was not found!" << endl;
            exit(0);
}
for (auto i(0); i < 3; i++){
            getline(matrix_file, sline);
            ssline.str(sline);                                                      //Convert to stream
            ssline >> intrinsic_matrix(i, 0) >> intrinsic_matrix(i, 1) >> intrinsic_matrix(i, 2);
            ssline.clear();
}
matrix_file.close();

//-----------------------------------------------------------------------------------------------
data1.txt:          r00 r01 r02 t0,  data2.txt …        //include Rotation matrix and translation vector
                        r10 r11 r12 t1
                        r20 r21 r22 t2

Read all file data1.txt … datak.txt:             // k file data.txt

CMatrix extrinsic_matrix(4);                            //create matrix 4x4
CMatrix Rotation(3);                                        //Rotation matrix
CMatrix Rotation_Transpose(3);                      //Transposed matrix of the rotation matrix
CVector Translation(3);                                    //Translation vector

ostringstream RT_file;    
string sline;
istringstream ssline;
ifstream datafile;

for (auto i(0); i < k; i++){
      RT_file << “c:/input_data/ data”<< k << txt”;     //direction of file

datafile.open(RT_file.str());

if (!RT_file.str().data()){
       cout << " RT_file was not found!" << endl;
       exit(0);
}

for (auto i(0); i < 3; i++){
       getline(datafile, sline);
       ssline.str(sline);                                                      //Convert to stream
       ssline >> extrinsic_matrix(i,0) >> extrinsic_matrix(i,1) >> extrinsic_matrix(i,2);
       ssline.clear();
}
datafile.close();

 //It is necessary in order to homogeneous coordinates
intrinsic_matrix(3, 3) = 1.0; //fourth column,fourth row :1
extrinsic_matrix(3, 3) = 1.0; //fourth column,fourth row :1

for (int x(0); x<3; x++){
       Translation[x] = extrinsic_matrix(x, 3);                        //only 3rd column
       for (int y(0); y<3; y++){
                   Rotation(x, y) = extrinsic_matrix(x, y);
       }
}

//To return the initial state
RT_file.str(empty_string);
RT_file.clear();

}

Write to file .txt

CVector3d* Up_Camera;   //output

string camerafile = "D://output_file/Up_Camera_Position.txt";
ofstream outfile(camerafile);

for (auto i(0); i < k; i++){
                                                     //calculate the Up_Camera.x,y,z and then save:
….
outfile << Up_Camera[k].x << " " << Up_Camera[k].y << " " << Up_Camera[k].z << endl;


}

Thứ Ba, 8 tháng 12, 2015

How to Become a Computer Scientist

Being a Computer Scientist is not about programming; it is about the study of algorithms (a series of steps, understood by someone or something, in order to complete a task in a given number of steps). Many Computer Scientists don't program at all. Indeed, Edsger Dijkstra once said “Computer science is no more about computers than astronomy is about telescopes.”

Part 1 of 4: Starting out


  1. 1
    Become a lifelong learner. Being a computer scientist is all about learning to be a student, not just during training, but for all time throughout your career. Technology changes, new languages develop, new algorithms are devised: you need to be able to learn new things to stay current.

  2. 2
    Understand your future role. As a computer scientist, it is your job to solve problems. It is also about solving problems in a way which can leave everyone happy in the end. This means learning good communication skills as well as coding skills because you are more likely to match the needs of your client with the apt solution if you listen well and relay back your understandings clearly, as well as keep the client informed during the project.

Part 2 of 4: Writing pseudocode


  1. 1
    Start with pseudocode. Pseudocode isn't really a programming language, but it is a way to represent a program in a very English-like way. The most familiar algorithm to you is probably on your shampoo bottle: Lather, rinse, repeat. This is an algorithm. It is understandable by you (the "Computing Agent") and has a finite number of steps. Or does it ...

  2. 2
    Tweak the pseudocode. The shampoo example isn't a very good algorithm for two reasons: it doesn't have a condition to end on, and it doesn't really tell you what to repeat. Repeat lathering? Or just the rinsing. A better example would be "Step 1 - Lather. Step 2 - Rinse. Step 3 - Repeat steps 1 and 2(2 or 3 times for better results) and then finish(exit)." This is understandable by you, has an end condition (a finite number of steps), and is very explicit.

Part 3 of 4: Writing algorithms


  1. 1
    Try writing algorithms for all sorts of things. For example, how to get from one building to another on campus, or how to make a casserole. Soon, you'll be seeing algorithms all over the place!

  2. 2
    After you've learned how to write algorithms, programming should come naturally to you. Buy a book, and read it entirely to learn the language. Avoid online tutorials as they're often written by hobbyists, not professionals.
    • However, feel free to look for help on the internet. Object-oriented languages like Java and C++ are "in" right now, but Procedural languages like C are easier to start with because they deal solely in algorithms.

  3. 3
    Programming is only the translation of pseudocode into a programming language. The more time before programming you spend planning in pseudocode, the less time you'll spend typing and scratching your head.

Part 4 of 4: Algorithm analysis


  1. 1
    Read up on RAM (the random access machine). One of the best places to start is by reading Steven Skiena's book The algorithm design manual.

  2. 2
    Learn about the limiting behavior of functions. Read up on Big O notation.

  3. 3
    Read about how worst case inputs can break your algorithm or cost you heavily in CPU processing time. It is important to learn what ways can efficiently counteract them.
  4. http://www.wikihow.com/