If it is not very big, Matlab handles it very well; if you do not have access to a "paid" (that is, "full") version, then there are free ones, I think, that work for not too big problems. 

Dear Khan: You may do this by using maxima. Please, follow this ; http://maxima.cesga.es/

In order to solve your system, you must enter it in the Maxima syntax.

For example, you may try to solve this 20X20 linear system :

solve([x1-3*x10+x11-3*x12-3*x13+3*x14+5*x15+x16-x17+5*x18-5*x19-3*x2+4*x20-4*x3-5*x4-4*x5+4*x6+3*x7+3*x8+x9=-2,2*x1+5*x10-4*x11+2*x12-5*x13+5*x14-x15+4*x16+x17-3*x18+3*x19-x2+3*x20-4*x3+x4-2*x5+2*x6-3*x7+4*x8-5*x9=-3,-4*x1+4*x10+x11-3*x12-x13+2*x14-5*x15-2*x16-x17+2*x18+x19+2*x2+4*x20+4*x3+x4-5*x5+5*x6-3*x7+5*x8-4*x9=0,2*x1+5*x10+2*x11-4*x12-2*x13+x14+4*x15-3*x16+4*x17+x18+3*x19+5*x2+4*x20-3*x3-2*x4+2*x5+x6-x7-x8+4*x9=-1,-4*x1+5*x10+4*x11+4*x12+x13+4*x14-3*x15-2*x16+2*x17+x18-2*x19+5*x2+x20+x3-5*x4+4*x5-2*x6+5*x7-2*x8+5*x9=1,-x1-3*x10-2*x11-2*x12+2*x13-3*x14-4*x15+2*x16-2*x17-3*x18+2*x19-2*x2+2*x20+5*x3+2*x4-5*x5-2*x6+x7-4*x8-x9=-3,x1+5*x10+3*x11-x12+5*x13-x14-5*x15+5*x16-4*x17+2*x18+5*x19+4*x2+4*x20+3*x3+5*x4+4*x5-x6-4*x7+4*x8+4*x9=0,-5*x1-2*x10-3*x11+4*x12+4*x13+5*x14-x15-3*x16+4*x17+4*x18-5*x19-2*x2+4*x20+x3+2*x4-4*x5+2*x6+x7-x8-5*x9=-3,-x1-4*x10-3*x11+2*x12-4*x13-5*x14-4*x15-2*x16-3*x17-5*x18+2*x19-4*x2+5*x20-x3-2*x4-5*x5-4*x6-4*x7-5*x8-4*x9=0,4*x1+2*x10+2*x11-4*x12+4*x13-5*x14-5*x15+4*x16+x17+4*x18+x19+5*x2+4*x20-2*x3+2*x4+4*x5+4*x6-2*x7+3*x8+3*x9=1,5*x1+2*x10+2*x11+2*x12-5*x13-2*x14-3*x15-2*x16+4*x17-2*x18+2*x19+4*x2-4*x20+5*x3+x4-2*x5+5*x6-4*x7+4*x8-2*x9=3,2*x1-4*x10+4*x11+4*x12-5*x13-4*x14-3*x15+3*x16-4*x17-x18+5*x19-2*x2-4*x20+5*x3+5*x4+2*x5-2*x6-2*x7-2*x8+2*x9=1,-4*x1-x10-3*x11+x12-5*x13+2*x14+4*x15+3*x16-4*x17-2*x18+2*x19-3*x2-5*x20-3*x3-2*x4+5*x5+5*x6-4*x7-4*x8-2*x9=-2,3*x1-3*x10+5*x11+x12-5*x13-5*x14-5*x15+3*x16-x17+2*x18+x19-2*x2+3*x20+3*x3+5*x4+4*x5-3*x6+2*x7-5*x8+3*x9=-2,-3*x1-3*x10-x11+2*x12+4*x13-4*x14+x15-3*x16-2*x17-4*x18-3*x19+4*x2+3*x20+4*x3+2*x4-x5-3*x6-4*x7+x8+x9=-1,3*x1+5*x10+x11-4*x12-4*x13+x14+5*x15-4*x16-3*x17+3*x18+x19+3*x2+2*x20-5*x3-x4+5*x5+x6+2*x7+2*x8-5*x9=2,2*x1-4*x10-5*x11+5*x12+3*x13-2*x14-3*x15+2*x16+5*x17+x18+5*x19+3*x2-2*x20+4*x3+4*x4+5*x5+x6-5*x7-3*x8-x9=2,2*x1-4*x10-5*x11-x12+3*x13-4*x14-2*x15-2*x16-5*x17-3*x18-5*x19-2*x2-2*x20-3*x3+5*x4-2*x5-3*x6+4*x7-4*x8+2*x9=1,-4*x1+x10+3*x11-5*x12-x13-2*x14+x15-3*x16-2*x17-2*x18-4*x19-4*x2-x20+4*x3+2*x4-4*x5-x6+3*x7+x8+4*x9=0,x1-3*x10-5*x11-4*x12-4*x13+3*x14-2*x15-5*x16-5*x17-x18+x19+3*x2+2*x20+3*x3+3*x4+4*x5-4*x6-4*x7-4*x8+4*x9=-3]);

Try this :

A:matrix([-2, 3, -2, -4, -5, 5, -4, 5, -4, 4, -1, -1, -4, 4, -2, -5, -3, 4,

4, -3], [-4, -2, -3, 2, 1, -2, 3, 1, 2, 5, 1, 2, -5, 1, -1, 2, -4,

1, 2, 5], [-5, -4, -1, -2, -4, -1, 4, -1, 2, 1, 2, 2, 3, -5, 3, -5,

5, 5, 5, 4], [4, -2, 4, 3, 5, 4, -3, 2, -4, 5, 5, 2, -1, 1, -1, 2,

4, -3, 4, -5], [-4, 5, -4, -2, 4, 3, -1, 5, -4, -4, 1, -3, -5, 4,

5, -5, -2, 1, -3, 4], [1, -4, 1, 5, 2, -4, -4, 1, 5, -1, -4, -1, 5,

5, 2, -5, 4, -1, -2, 3], [-1, 1, -2, 5, -3, -2, 3, 5, -2, 4, -4, -5,

3, 2, 1, 2, 1, 4, -4, -4], [5, 4, -5, -3, 3, -5, -5, 5, -4, -4,

3, -5, -4, -3, -4, 4, 2, -1, 1, 3], [4, -4, 5, -1, 5, 2, 1, -5, -4,

2, -3, 3, 1, -5, 2, -3, -1, 3, -1, -4], [-1, -2, -3, 2, 3, -1, 2,

3, -3, 1, 2, -1, 3, 4, 4, 5, -3, -1, 1, 3], [-1, 3, 3, 5, -5, 4, -1,

2, 5, -2, 3, 2, 1, -4, 4, 4, -2, 1, 5, -5], [4, 4, -5, -1, -4, -4,

5, -4, 3, -3, -1, 3, 4, 5, 3, -4, -5, 3, -3, -4], [2, 4,

3, -1, -5, -1, -5, 5, -2, 2, -5, -1, 3, -3, 3, -4, 3, -5, -2,

5], [2, 4, -2, -4, 4, -3, -3, 1, -2, 4, 1, 1, 2, 3, 2, 2, 3,

5, -5, -3], [2, 3, -5, 1, -2, 3, -4, -1, 4, -1, 1, -4,

3, -3, -4, -4, 2, -5, 3, -2], [-3, 3, -3, -5, 4, 4, 2,

2, -3, -1, -1, -3, 2, -2, -2, 5, -4, -1, -4, -5], [1, -3, 5, 3, -4,

3, 5, 3, 1, -2, 3, -4, -2, 3, 5, -3, -3, 4, 2, -5], [-2, 3, -2, -2,

3, -4, 2, -3, 2, -3, 3, 4, -5, 2, 1, -2, 4, -3, 2, 5], [4, 5, 4, -3,

3, -5, 3, 1, -5, -3, 5, -3, -2, -3, -2, -2, -1, 4, -3, 3], [-2,

1, -5, 3, -4, -4, -2, -5, 5, -5, 1, -2, -2, -2, 4, 4, 3, 5, -2, 5]);

B:[-4,-5,5,-3,-1,3,1,-4,3,3,3,5,-4,-4,-2,4,-2,1,3,-4];

X:[x_1,x_2,x_3,x_4,x_5,x_6,x_7,x_8,x_9,

x_10,x_11,x_12,x_13,x_14,x_15,x_16,x_17,

x_18,x_19,x_20];

EC:list_matrix_entries(A.X-B); linsolve(EC,X);

The best way is to use LAPACK. See

http://www.netlib.org/lapack/

It contains state of the art numerical algorithms. You can either use Gaussian elimination or  a QR factorization.

Moreover there exists a C++ version.

You have to take into account of the specific structure of A;for instance, whether A is dense or sparse, structured or of general form?Gaussian elemination or matrix factorization approach, or Sadok's CMRH are helpful for dense problem. otherwise, you may try Krylov subspace methods. 

Perhaps the easiest way is to use the Matlab language, as comented above:

X = A\B

But Matlab is privative software and you need a license. For this simple task, I recommend Octave, https://www.gnu.org/software/octave (compatible with Matlab language).

Or, if you like the python language, Python+Numpy, http://www.numpy.org. Or, Maxima, or Fortran, or...

Mathematica Code

A = {{1, 2, 3, 4}, {-2, 3, 4, 0}, {-3, 4/5, 3, 2}, {0, 0, 5, 8}};

B = {5, 6, 7, 8};

LinearSolve[A, B]

The outpu:

{-319/225, 56/45, -32/225,

49/45}t

Wolfram Alpha ( works when the matrix dimension is not too long !)

http://www.wolframalpha.com/input/?i=A+%3D+{{1%2C+2%2C+3%2C+4}%2C+{-2%2C+3%2C+4%2C+0}%2C+{-3%2C+4%2F5%2C+3%2C+2}%2C+{0%2C+0%2C+5%2C+8}}%3B++B+%3D+{5%2C+6%2C+7%2C+8}%3B++LinearSolve[A%2C+B]

Singular Value Decomposition, unless your data is a complete set of Tuples.  Then you can use a closed-form equation that is simply a scaled transpose.  See youvan.com; it's in the grant proposal I published to look for alternative genetic codes.  We used this method to get 12 weights (3 positions x 4 nucleotides) of how the codons relate to hydropathy and molar volume.  SVD is the function PseudoInverse in Mathematica.  It will blow up on you if your matrix is large: the scaling is a x^2 in CPU and x^3 in memory!  My method is linear.

Go for Artifical neural network .... tune your decision vriables as a neural and compare it with B vector .....

Thanx to all of u for your comments.

Apply Gauss Elimination method and find the solution.

By using maple program for any direct method for solving  linear system but the easy method we can use   Gauss elimination method if you have initial value for your system easy you use Gauss Ziedel is the best way for indirect  methods