{'fraction_non_alphanumeric': 0.03675031901318588, 'fraction_numerical': 0.010463632496809868, 'mean_word_length': 4.438584316446912, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 1, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Development of a Java Package for Matrix Programming

We had assembled a Java package, known as MatrixPak, of four classes for the purpose of numerical matrix computation. The classes are matrix, matrix_operations, StrToMatrix, and MatrixToStr; all of which are inherited from java.lang.Object class. Class matrix defines a matrix as a two-dimensional array of float types, and contains the following mathematical methods: transpose, adjoint, determinant, inverse, minor and cofactor. Class matrix_operations contains the following mathematical methods: matrix addition, matrix subtraction, matrix multiplication, and matrix exponential. Class StrToMatrix contains methods necessary to parse a string representation (for example, [[2 3 4]-[5 6 7]]) of a matrix into a matrix definition, whereas class MatrixToStr does the reverse.


Introduction
We used Java for our program is because it is an easier language to use and is more widely used. Because that Java has a library to use from, we are able to do simple basic algebraic calculations. Java is widely used over the internet, so people from all over the world is able to gain access to our program and thus we would be able to aid more people. Java uses applet, which allows users to do matrix calculations over the internet.
So this is why we used Java as the computer language to write our program.
This program is all about matrix. We wrote it to help people through out the world to solve matrices problems that are simply too hard and long to do. We did this program on matrix are for various reasons, firstly, for someone to do matrix calculations in large sums, example a 10 X 10 matrix, it would be very tedious, takes up a long time and could easily make a mistake. Second, matrices are more frequently used by engineers, commuters and a salesman, the matrices that they have to solve would be a lot bigger than a 10 X 10 matrix, so it would be nearly impossible for them to it, and if they really could, it would take a very long time. So we did this program as a remedy to these problems. Our program could also be used for students, teachers and many others, it could simply be used to solve simple matrices for students, or it could be used to do complicated matrices.
Our program has is able to execute many different operations, they are addition, subtraction, multiplication, transpose, inverse, cofactor, determinant, adjoint and power.
So, our program gives our users much help as operations like determinant and power are very tedious and long to do.

Historical computer algebra systems
Much of the attempts of symbolic and algebraic manipulation of mathematical equations using computer pre-dates the 1970s. A stream of emphasis on computer algebra systems then were towards symbolic solutions rather than numerical solutions as seen today. This emphasizes uses computers as automation, automating routine mathematics.
Many questions arise from using computers as mathematical symbolic manipulators. One of the tougher questions can be worded as follows: Given the large variety and complexity of equations, how can it be tackled effectively? No doubt, even till today there's no one system capable of handling all equations. Nevertheless, there are works in this area. By the work of Kamke [KAM61] in the late 1950s, he generalized the number of types differential equations into 367 forms, and demonstrates the treatment of each type. This formed the basic of certain systems in the 1970s, such as, that of Schmidt's [SCH76] EULE.
Much of the programmes mentioned earlier uses heuristics as symbolic solutions are greatly heuristics such process. In EULE [SCH76], differential equations are treated by the methods described by Murphy [MUR60], with the knowledge presented by Kamke [KAM61]. It first attempts to simplify the given equations before searching for a method of solution.
Slapler's SAINT (symbolic automatic INTegrator) [SLA63] started as part of the doctoral these of the author in Massachusetts Institute of Technology (MIT) [SLA61]. Its main procedure is by constructing a tree and pruning from it at the same time until a solution is reached, which had been previously described [NEW57]. At each stage, cost is calculated for OR trees and costly branches are pruned.

Symbolic Input
In all computer mathematical systems, one of the essential and implicit problems to encounter is the mean of symbolic input. How can equation be entered into a computer via mainly the keyboard? How will these inputs be entered and understood? The problem arises as mathematical notations are two-dimensional scripts and computers can only read one-dimensional scripts. Until later years where GUT and mouse become common, the keyboard is the sole input device. Thus, how to fit a two-dimensional scripting into a single dimension, without losing its implicit meanings, becomes a thing to solve.
The first electronic computer was created to reduce time in calculation. It was until the late 1970s that they had other agenda. Hence its sole purpose then was in mathematics.
Computer programmes, even today, are essentially nothing more than lists of formulas. In the 1950s, work was dome in creating a language known as FORTRAN (FORmula TRANslator) for such a purpose. In fact, FORTRAN was the first programming language that was standardized, known as FORTRAN66 [FOR66], since it was 1966.
However, there were many symbolic input methods and schemes that did not fall into the mainstream as FORTRAN. They were developed as more specialized ways by different groups to attack specific areas of mathematics. At the same time more general schemes were also developed. Early methods were mainly text-based, such as Ossenbruggen's [OSS71], Barton's [BAR70], AUTOMAST [BAL66] and SCRATCHPAD [JEN74].
Despite being textual systems, early systems have great degree of variance in the input methods. Ossenbruggen [OSS71] uses a rather structure less model as compared to Barton [BAR70], which requires a programmatic structure in based on total Autocode [BAR67]. In this aspect it is similar to FORTRAN, in the spectrum, AUTOMAST [BAL66] requires a semi-structure in its input, which is of much lesser stringency than that on Barton's. SCRATCHPAD [JEN74] is implemented as an interactive semi-programming environment. Being so, there are defined structures and syntax. However, it can also be seen as a communication schemes there are essential no processing behind the interface.
SCRATCHPAD is this, an elaborated user interface.  [ZHA96]. However, MathScribe portrays less stringency in the box language is highly structured to provide mathematical clarity whereas MathScribe relies on the natural mathematical representation and only inherits the box-like structure from it. Hence, in MathScribe, there is no explicit definition of the box.
Mathematica is a commercial suite that uses a relative of box language, known as Bra-ket Notation [HAR00]. Bra-Ket Notation is implemented as "function-like" methods. With resemblance to function calls in many programming languages, each box has a defined name and parameters. These functions or boxes can either play formatting roles, like superscript functions or boxes can either like Laplace Transform. Bra-Ket Notation adapts a linear scheme of input, which will mean that readability suffers.
OpenMath [PRI00] is one of the two major moves of moving natural mathematical notation into the Internet. The other being MathML (Mathematical Markup Language). It mimics the implementation of HTML [RAG99]. Due to the nature and the length of the document produced in either OpenMath or MathML, native readability suffers greatly and often, error detection is impossible without an able browser.

Matrix Operations 1
For the purpose of this project, the following matrix operations are considered: addition, subtraction, multiplication, power, transposition, minor, cofactor, adjoint, inverse and determinant.
Given two matrices, A = [a i,j ] and B = [b i,j ], where i is the row position and j is the column position of the elements in the matrix. For this section, the above definition and notation maintains. Under circumstances where the number of rows and columns of A and B are respectively equal, matrix addition is defined as [a i,j + b i,j ]. The resulting matrix will have the same row and column size as A or B. [Σ( a i,j x b i,j )] (row multiplied by column). Another method is to transpose matrix A, and then do a column multiplied by column operation. The product of two matrices will have the number of rows of A and the number of columns as B. Power or exponential operation on matrices is similar to multiplication of scalar values.
Given a matrix, A = [a i,j ], the transpose of A is defined as, A T = [a j,i ]. In simple terms, the rows become the columns and the columns become the rows.
The minor of a matrix is a reduced size matrix. A minor is denoted as |M i,j |, and it reduces the size of the original matrix (assumed to be M x N) to (M-1) x (N-1) matrix by deleting row i and column j of the original matrix.
Cofactor is also known as signed minor. As the name implies, it is an extension from a minor. Hence a cofactor is defined as (-1) i+j a i,j |M i,j |.
An adjoint of a matrix is defined as the transposition of cofactor matrix.
Inverse of a matrix is defined as the scalar division of the adjoint matrix by the determinant of the matrix.
Given a 2 x 2 matrix where row 1 is [a,b] and row 2 is [c,d], the determinant is defined as (ad -bc). In the case of a higher order matrix, it is then reduced to a 2 x 2 matrix via recursive cofactoring operation.

Java Programming Language Features 2
Java is a programming language platform from Sun Microsystems. It is a simpler langauge as compared to C or C++. The language is object oriented. By using Java, your 2 Information for this section is gathered from the following source, [GOS96] development cycle is much faster because Java technology is interpreted. The compilelink-load-test-crash-debug cycle is obsolete. Now you just compile and run. Your applications are portable across multiple platforms. Write your application once and you never need to port them -they will run without modification on multiple operating systems and hardware architectures. Your applications are robust because the Java runtime environment managers memory for you. Your interactive graphical applications have high performance because multiple concurrent threads of activity in your application are supported by the multithreading built into the Java programming language and runtime platform. Your applications are adoptable to changing environments because you can dynamically download code from anywhere on the network. Your end users can trust that your applications are secure, even through that downloading code from all over the internet; the Java runtime environment has built-in protection against viruses and malicious codes. So the Java programming platform provides a portable, interpreted, high-performance, simple, object-oriented programming language and supporting runtime environment.
Java is simple as it can be programmed without extensive programming training while being attached to current software practices. The fundamental concepts of Java technology are grasped quickly; programmers can be productive from the very beginning.
Java is object oriented, the needs of distributed, client-server based systems coincide with the encapsulated, message-passing paradigm of object-based software. To function within increasingly complex network-based environments, programming systems must adopt object-oriented concepts. Java technology provides a clean and efficient object-based development platform.
Java is a similar language as it looks like C++. Java is easier as it removes the complications of C++. Having the Java programming language retaining many of the object-oriented features and the "look and feel" of C++ means that programming can migrate easily to the Java platform and be producing quickly. Java is Robust as it was designed for creating high reliability. It provides extensive compile-time checking, followed by a second level of runtime checking. Java is secure as it was designed to operate in distributed environments, which means that security is of paramount importance. High security features designed into the language and runtime system, Java technology lets you complete applications written in the Java programming language are safe from intension by unauthorized code file systems.
Java is designed for network usage as the java complier produce bytecodes on architecture neutral intermediate format designed to transport code efficiently to multiple hardware and software platforms.
Java is portable as it was the language platform of Java technology known as Java Virtual Machine.
Java has high performance as it adopts a scheme by which the interpreter can run at full speed without needing to check the runtime environment. It has the automatic garbage collector to ensure high memory.
Java is an interpreted language. The Java interpreter can execute Java bytecode directly as any machine to which the interpreter and runtime system has been ported. Java technology's multithreading capability provides the means to built applications with many concurrent threads of activity. Multithreading thus results in a high degree of interactivity for the end user.
Java is dynamic as the language and runtime system are dynamic in their linking stages. We define a matrix as a two-dimensional array of float.  ))) +

Matrix definition
Computationally, we define a numerical matrix as a two-dimensional array of float elements, with the number of rows and the number of columns of the array stored as discrete variables.
Mechanically, a matrix representation is entered into the library as String of characters.
Each elements in the row is separated by a space, for example, "3 4 5". Each row is definitely enclosed by "[" and "]", for example "[3 4 5]. Each row is linked consecutively

Matrix is typed as a string in this from, example -> [[2 3 4]-[2 3 4]-[2 3 4]].
We clear everything before and after the first and last brackets. in the matrix. Next we get rid of all the other brackets. But it is still in string form, so we break the strings out the white spaces in between. We change it into string buffer, then to string and finally to float. After all these are dome, we will get our matrix.

Transpose
Transposing a matrix is simply to change a matrix's row into column and column into row. By doing so in java, we take it that each number in the matrix like (1,2), has a coordinate point. Example 'I' in the matrix has a coordinate point of (0,0) and 2 has a coordinate point of (1,0) and so on. So to flip the row to column and column to rows, we flip the coordinate point. Example to transpose (1,2) into (1,3), the coordinates of '2', (0,1) would change to (1,0) and so its position in the matrix is flipped. In Java, we have 'i' for rows and 'j' for columns, so it is (i,j). After we flipped the matrix, we would get (j,i). Example: When there are no errors, matrix m is created as a result (new object).
We use two if statements to check row and column.
When row size is not equal, statement showing error is thrown.
When column size is not equal, statement of showing error is thrown.
When p.rowsize is equivalent to q.rowsize, for loop is used to find the coordinate points of the integer using i and j.
Using matrix addition law, i of matrix p is added to i of matrix j.
Since m is created as a new object, m is the end result of the addition and returns to the main. Example:

Subtraction
For subtraction, two matrices p and q is taken in and returns object m.
Matrix m is a new object that has the same row and column size with p.
Two if statements are used to check for row size and column size.
If p.rowsize is not equivalent to q.rowsize, Arithmetic Exception is thrown in to declare that there's a difference in row size.
If p.colsize is not equivalent to q.colsize, Arithmetic Exception is thrown in to declare that there's a difference in column size.
When there are same row and column size, for loop is used to find the coordinate points using i and j, by using i++, which increases by 1 for every loop. Until I reaches the row size, for loop is used to find the coordinate of j and increases by 1 in every loop. M, the new matrix object stores the value of end result of subtraction of p and q which is done according to matrix subtraction law.
M is returned to the main. Exanple:

Power
In this function, it takes in matrix p, integer n, where n is the value of power.
Since it is in public, it can be called by any other classes when necessary.
If statement is used to check when n is equivalent to 1, it returns to original matrix p as in all cases when the power equals to 1, the value remains the same.
Else is used to check when n is not equivalent to 1. If statement is used to check when n=2, by calling multiplication class, p is multiplied by p (itself), which means p^2. The product matrix is then returned to the main.
Another else statement is used to check for n is neither equivalent to 1 nor 2.
When n is neither 1 nor 2, by using multiplication class, integer n is reduced by 1 and p is multiplied by itself according to the result of n-1 times before multiplying p again.
For example, when n=3, where p; (p.2) which means p;(p(p)) where p;(p,2) which means p;(p(p)). Hence the value becomes p*p*p which is equivalent to p^3. Example:

Extraction of minor from p matrix by an element
There are fine cases in getting the minor of the matrix, they are, (0.0) ; (row, 0) ; (0, col) ; (row, col) ; (row-m, col-n). By using a 10 by 10 matrix as an example, for the first case, to get the minor, a 9 by 9 matrix, we would have to eliminate the first row and first column. So now, we have a 9 by 9 matrix, but the coordinate points of the first number would be (1,1). Because that Java array starts with (0,0), so we would need to change the matrix to start from 0,0. To do that, all we have to do is to -1 for row and column, then we would have a correct 9 by 9 matrix. Now, for the second case, (row,0) which means the last row and first column, we have to eliminate them. By using a 10 by 10 matrix as an example, we want to get the minor of it, a 9 by 9 matrix. After we eliminate the last row and first column, the coordinates now have to be moved to the left which means that the column all must be -1. so after doing that we would get a correct 9 by 9 and 10 by 10 matrix. Now, for the third case, (0,col), we would have to get rid of the first row and last column. By using a 10 by 10 matrix as an example, we want to get the minor, a 9 by 9 matrix. We after eliminating them, we would need to move the matrix up so that, it would start from (0,0). To do that, we would -1 for the row of all the coordinate points. Then we would get a correct 9 by 9 matrix.
For the forth case r (row, col), we have to eliminate the last row and last column. Using a 10 by 10 matrix 0,0 as an example, we want to get the minor of it, a 9 by 9 matrix. After eliminating the last row and last column, we would get a correct 9 by 9 matrix straight away because the coordinates starts from (0,0) already.
For case 5, we need to eliminate (n,m). n is the row somewhere between the first and last and m is also the column somewhere between the first and the last. By using a 10 by 10 matrix as an example, we want to get a 9 by 9 matrix which is a minor of it. To do that, we eliminate n row and m column, after that, 10 by 10. We have to paste the four parts, labeled 1, 2, 3 and 4 on the diagram together. The first part 1, we do not need to do anything since it is already in its correct position. So for the second part, 2, we have to move it to the left in the diagram, so to do that we -1 for the column.
For the forth part, we have to -1 for its row and columns. Then we would get a correct 9 by 9 matrix. Example:

Multiplication
For matrix multiplication, the number of columns of the first matrix and the number of rows of the second matrix must be equal, and the product has a size of the number of rows of the first matrix and the number of columns of the second matrix. Regularly, matrix multiplication requires the summation of the product of row elements and column elements. However, for computational simplicity, it is changed to the summation of product of column elements of the first matrix and the column elements of the second matrix. In order to do so, transposition of the first matrix is required. Hence, summation of the product of the column elements of the transposed first matrix and the column elements of the second matrix yields the element of the first row and first column of the product (resultant) matrix. In another words, upon transposition of the first matrix, the column number of the transposed matrix will determine the row position of the product, whereas the column number of the second matrix will determine the column position. Example:

Determinant
First, we need to find that if it is a 2 by 2 matrix, if it is, then we would have (2x6 -4x5).
If the matrix is not a 2 by 2 matrix, we would create n number of arrays; each array would have a minor of n-1. Then for the n-1 matrix, we would repeat what was done until we get n = 2. When we want to get the determinant, we need to add the minors up, to do that, each minor, we need to add them and subtract them alternately. Then we would get the determinant. Example:

Cofactor
To get the cofactor of a matrix, firstly, we let the matrix seem to have minor matrices within itself. Then in each individual minor matrix, we find the determinant. This step could also be called signed minor. We are actually getting the signed minor of the minor matrix. Then after we got it for each individual matrix, we put them together and get back a 4 by 4 matrix which is the cofactor matrix.

Adjoint
To get the adjoint, we simplify transpose the cofactor matrix and we would have our adjoint matrix. Example:

Inverse
To get the inverse of a matrix, we multiply each element in the adjoint matrix by the determinant.

matrix(int row, int col)
Creates an empty matrix of number of rows and columns as specified.   public matrix addition(matrix p, matrix q) throws java.lang.ArithmeticException

java.lang.ArithmeticException
ArithmeticException is thrown when either the row size of the 2 matrices are different (Error Message: addition(matrix p, matrix q) error. row size difference) or the column size of the 2 matrices are different (Error Message: addition(matrix p, matrix q) error. column size difference). subtraction Subtracts P and Q (P -Q) and exports the difference. public matrix subtraction(matrix p, matrix q) throws java.lang.ArithmeticException

java.lang.ArithmeticException
ArithmeticException is thrown when either the row size of the 2 matrices are different (Error Message: subtraction(matrix p, matrix q) error. row size difference) or the column size of the 2 matrices are different (Error Message: subtraction(matrix p, matrix q) error. column size difference).

multiplication
Multiplies P to Q (P.Q) and exports the product.

java.lang.ArithmeticException
ArithmeticException is thrown when the column size of P is different from the row size of Q (Error Message: multiplication(matrix p, matrix q) error.). Row assembly array of iniStrBuff.

StrBuffArrToFloatArr
Method to convert a two-dimensional StringBuffer array into a two-dimensional float array.