[PDF] pocketbrain: Matrix calculator application

while Desmos and BlueBit use decimals For each trial, a matrix was inputted into a calculator The application would compute the inverse, and then multiply it by

[PDF] Desmos matrix transformation - Weebly

Discover conversions of graphics with Desmos Graphics Calculator 90° looks like this: Multiplying a vector with a matrix converts this vector accordingly

[PDF] Algebra II CP

A matrix can be used to represent and efficiently solve a inequalities Using Desmos calculator 5 Flipped Add, subtract, and multiply matrices of appropriate

13 sept 2020 · multiplication, linear combination, transpose); 3b Matrix and vector multiplication Write down the augmented matrix corresponding to the system of the system from your week1 worksheet, or use desmos com/calculator

[PDF] Graphing calculator free for pc - Squarespace

Desmos Graphing Calculator started as a simple concept, but can now work on complex mathematical Although mathematically oriented programs like Universal Math Solver deal Some of the most common features are matrices,

[PDF] Graphing calculator for pc free - Squarespace

Desmos Graphics Calculator started out as a simple concept, but now it works with Math Solver, deal with more complex problems, this app remains a great choice for The most common functions are matrices, logarithms, and print lines

[PDF] Pre-Calculus Learning Plan - Systems of Equations - Georgia

N VM 9 Understand that, unlike multiplication of numbers, matrix Teacher Moves: Desmos has a powerful matrix calculator, https://www desmos com/matrix ,

[PDF] matrix multiplication calculator emath

[PDF] matrix multiplication calculator online

[PDF] matrix multiplication calculator with steps

[PDF] matrix multiplication calculator with variables

[PDF] matrix multiplication calculator wolfram

[PDF] matrix multiplication example

[PDF] matrix multiplication properties

[PDF] matrix operations

[PDF] matrix power

[PDF] matrix representation of graphs

[PDF] matrix row reduction

[PDF] matrix rref calculator wolfram

[PDF] matrix simultaneous equation calculator

[PDF] matrix solver

[PDF] matrix ti 89

Anthony Vuolo III

POCKETBRAIN: MATRIX

CALCULATOR APPLICATION

Abstract ......................................................................................................................................................... 2

Literature Review .......................................................................................................................................... 3

Introduction ............................................................................................................................................... 3

The User Interface ..................................................................................................................................... 3

The Basic Attributes of the User Interface ............................................................................................ 4

Matrices .................................................................................................................................................... 5

The Basics ............................................................................................................................................. 5

Examples of Complex Functions .......................................................................................................... 7

Accuracy ................................................................................................................................................... 9

Conclusion .............................................................................................................................................. 11

Charter ........................................................................................................................................................ 12

Materials and Procedure ............................................................................................................................. 13

Results ......................................................................................................................................................... 14

Conclusions ................................................................................................................................................. 19

References ................................................................................................................................................... 21

Appendices .................................................................................................................................................. 23

Appendix 1: Acknowledgements ............................................................................................................ 23

Appendix 2: List of Functions ................................................................................................................ 24

Appendix 3: Limitations and Assumptions ............................................................................................. 25

Appendix 4: Sample Code ...................................................................................................................... 27

Appendix 5: Notes File ........................................................................................................................... 35

Appendix 6: Field Competitors Handheld Graphing Calculators ........................................................ 44

Abstract

A matrix is a two-dimensional set of values used for storing numerical information, depicting transformations on a coordinate plane, computing statistical data, or even encoding neural networks. Matrix computations are taught in linear algebra and advanced modeling courses in college curricula, in preparation for use in real occupations. Current free matrix calculators are often inaccurate, function under a user interface that is difficult to navigate, or lack important traits such as exportable data. The goal of the project was to engineer an application that performs most college-level matrix calculations while maximizing computational accuracy and usability. The program was coded to include a list of attributes that functioned as guidelines for optimizing compared to other programs using function accuracy tests and a scoring matrix that included user interface assessments. A free matrix calculator with maximal usability and exact computational results will make calculations faster and easier, allowing matrices to truly become the standardized format for data storage. 3

Literature Review

Introduction

Matrices are used in many different areas of math. They are useful for calculating changes in two-dimensional motion and in making changes to large groups of data. This method of storage is compact, reliable, and versatile, as it can be converted into many different forms. However, even basic calculations with matrices can be tedious; operations as basic as multiplication require realigning the two factor matrices and multiplying long strings of elements for each section of the product matrix. For this reason, it is more efficient to use programmed calculators to perform operations on these data types. In addition to the long list of mathematical methods one must code to provide an adequate calculator, one must engineer a user interface that a human being ca between user and program should be organized and visually appealing, implementing an operation system that allows data to be easily entered and neatly displayed in different forms. Many matrix calculators have interfaces that do not allow easy navigation or have inefficient systems for accepting input. For this reason, there is a need for an application that can run accurate matrix calculations in a user interface that can easily support the display requirements of any size matrix in an organized navigation system.

The User Interface

The user interface, abbreviated as UI, is the set of programs that allows a human being to find the resources needed from a website or application. The interface is important because it represents all interactions between the code and the user; only a well-designed UI will allow easy access to all the functions the program has to offer. Coding languages built for this part of an 4 application include HTML and CSS; however, other languages do support graphical images and other visual effects.

The Basic Attributes of the User Interface

The menu is the basic UI component that allows any and all interaction with a computer application to take place. Although often overlooked, the state of the menu is what has the most influence on the usability of the program. A properly functional menu is uncondensed, allowing the user to skim it for the functions or submenu of interest (Pérez-Montoro, 2017). The interface should feature a description of each option to permit the user to preview a menu before choosing a function. An optional feature is to allow a list of functions to move around the screen; for some applications, this design could allow information on a page to be placed in any area and not remain permanently obscured (Oldenburg, 1989). This ability may also allow windows to overlap and reduce screen clutter for optimal use (Kerkez, 2000). Preferably, the information about the matrices in each menu would also be shared with other locations in the app (He, Shen, Li, Shi, and Zhao, 2010). The subsections of a menu contain functions or submenus that are too complicated or require too much visual space to be contained on the screen. Menu options should be organized in a sort of hierarchy or tree format, which can allow multiple function categories to be contained in a single screen (Tate, Goto, and Takeuchi, 1996). Another important detail about a user interface is its ability to undo an accidental action made by the user. Although most calculators do not implement this sort of code, it would make for a more navigable interface. The most basic function would be a set of forward and backward buttons for scrolling through program history, as these would allow the user to travel back and forth between menu layers (Pérez-Montoro, 2017). In the functions themselves, an undo and redo 5 button would allow a user to nullify any previous action made while developing a matrix without having to remove every single element.

Matrices

The Basics

The basic form of a matrix is a two-dimensional list of polynomials, although they usually use single numbers. A matrix can store lists of variable sets such as coordinate points. For such data points, square matrices can represent translations, rotations, dilations, or other coordinated movements across a coordinate grid. Matrices are also used in economic programs and in neural networks, which aid machine-learning algorithms (Christensen, 2003). Matrices have strange mathematical properties because of how their basic operations to a matrix, every element is multiplied by the scalar. However, the dot product uses a different mathematical technique. For computation, the product of an m-by-n matrix and a p-by-q matrix has dimensions m-by-q. For each element in the array, a row of the first matrix and a column of the second are lined up; elements are paired together, multiplied within their pairs, then summed to produce the new element. Because each value must have a pair with which to multiply, the number of columns in the first matrix must match the number of rows in the second. Dot product multiplication is associative but rarely commutative; switching the order of the matrices may produce a very different sum of dot products that can change the elements of the new array. This computation allows for a standardized division function, and certain matrix decompositions are computable by converting the dot product into a system of equations. The determinant of a matrix is what confirms the existence of a matrix inverse. When using the normal process of calculating the inverse of a square matrix, the final step is to divide 6 the matrix by its determinant; if the divisor is 0, then the inverse cannot be found using that method. Finding a determinant involves iteratively taking the determinants of smaller submatrices and summing them along rows in the matrix. When a value a is divided by a value b, the other way of interpreting the mathematical operation is noting that a is multiplied by the multiplicative inverse of b, or ଵ ௕. With matrices, division is performed differently because several terms are multiplied and added to form each element. Thus, multiplication by an inverse is the standard method of matrix division. The inverse of matrix M can be found by first creating a matrix A formed by the determinants of each M subsection to form the matrix of minors. Certain values in a grid pattern are then multiplied by -1 to form the matrix of cofactors. Once the values in this step have been transposed along the upper-left-to-lower-right diagonal the adjoint the whole matrix is divided by its determinant. Aside from standard division, the inverse of a coefficient matrix can be used to solve linear systems. The matrix inverse is one of a few specific matrices that can be commutatively multiplied by the original, and when this occurs the result is an identity matrix (Wang and Dai, 2010). This matrix is formed when a null matrix, or array of zeros, has ones placed along its main diagonal. The identity is essentially a multiplicative identity and behaves much like the number one does in the set of all complex numbers. It is its own multiplicative inverse, and when multiplied by any matrix M, the resulting product is the same array M. 7

Examples of Complex Functions

Linear systems of equations can be solved by using matrices. A series of linear equations can be modeled as an equality that sets the product of a coefficient matrix and an unknown column matrix equal to a constant column matrix. Fig. 1: A linear system set up to be solved by a matrix system 2014) This system can be solved by multiplying both sides of the equation by the inverse of the coefficient matrix; this would form an identity on the left with the unknowns and a column matrix on the right, whose values would then be equivalent to each corresponding unknown. Thus, by evaluating the inverse one has solved a linear system. Matrices can represent movement in a Cartesian coordinate grid; however, it is worth noting that complex numbers do the same. Thus, the two can be interchanged. Similarly, rotations using matrices can be performed using an arrangement of trigonometric identities. Eigenvalues are numbers used to designate the magnitude of Cartesian plane movements that a matrix performs on one or more coordinate points. When the eigenvalues of a matrix are added 8

to its diagonal elements, the determinant of the resulting matrix is 0; this subtraction can occur if

the product of an eigenvalue and a properly-sized identity matrix is subtracted from the original. Fig. 2: A visual of the characteristic polynomial being formed given the input matrix (Gundlach). The characteristic polynomial is the determinant of the resulting matrix; this will be in the form of a polynomial of degree n, where n is the size of the matrix. The roots of the polynomial will be the eigenvalues. When a matrix is multiplied by one of its eigenvalues, there is always a matrix n such that when multiplied by the original matrix produces the same result.

This is known as an eigenvector.

Matrix decomposition is the name given to a set of complicated operations. However, most decompositions have a common characteristic: they often produce multiple matrices. For example, lower-upper decomposition strips an array into two components: a reformed identity matrix where any nonzero values appear below the main diagonal, and an upper triangular matrix where all nonzero numbers are at or above the diagonal. A complicated system of equations, split using Gauss-Jordan elimination, is solved to produce all nonzero values so that the product of the two matrices is the original. When representing a linear system, coefficient matrices with more zeros are easier to solve because there are fewer variables per equation. Thus, many 9 decompositions of a matrix result in a simpler set of coefficient arrays to encode variables. As with inverses, some matrices do not have a lower-upper decomposition.

Accuracy

A problem with calculators, common between handheld models and web applications alike, is that they often perform calculations using decimals. Decimals provide very accurate answers that allow the calculator to continue with its computations using numbers that usually produce the right results. Some similar variable types, such as floating-point values, allow a computer to work at faster speeds (). However, decimal answers are almost always approximate. Irrational numbers are truncated or rounded, and rational numbers are sometimes represented the same way, upsetting simple calculations. Floating-points use

Ichimura,

Katagiri, Ozaki, Ogita, and Nagai, 2018). Erroneous rounding can cause large or obvious deviations between answers; calculator programs such as Desmos and BlueBit do not always produce an identity matrix when they perform multiplication on a matrix and its inverse because of errors in significant figures. Even Java programs with primitive decimal-based data types can be prone to errors where exact values, such as terminating decimals, are recorded incorrectly. For certain calculators, a solution to the accuracy problem could be to use fractions. Since a fraction can represent any rational number with no error or rounding, any calculator that does not require irrational numbers in its output matrix can implement a fraction-based variable storage system. In an experiment, a few matrix calculators were tested for error using their inverse function. A Java program and an online calculator called Wims use fractions for storage, while Desmos and BlueBit use decimals. For each trial, a matrix was inputted into a calculator. The application would compute the inverse, and then multiply it by the original matrix. The 10 resulting product would be a matrix close to, if not congruent to an identity matrix. The residual errors of each element as deviating from the respective elements of the identity matrix were taken and logged. As is shown in Fig. 3, the fraction-based programs experienced no residual error. The output from Desmos had enough deviation to be visible in the output matrix. The resulting matrix from BlueBit, since the numbers could not be stored directly in the program and had to be manually copied from another output screen, had the largest error; this amount of inaccuracy would be likely to accumulate through multiple computations and lead to wrong results. Overall, this experiment supports the use of fractions over that of decimals because fractions maintain exact values. Table 1: A recording of residual error for the identity matrix given from each calculator. Matrix Calculator Operation Input Matrix Residual Error

Java Program Inverse 3 5 -3

4 2 1

11 6 7

Wims Inverse Ͳ

However, some types of decompositions and other matrix computations require using the irrational roots of integers. Fractions cannot represent such values. In many cases, this problem can be solved with radical numbers. Radicals function as a unique variable type; a radical and a non-radical cannot be added into a single term. However, the existence of radicals allows irrational numbers to exist in their exact forms. Quadratic equations can be solved without the need for decimals by using radicals of root 2, which allow some quantities, such as the eigenvalues of small matrices, to be found in exact value. Some radical exponents have simple simplification methods; any exponent power of 2 can be iteratively squared until all roots have been eliminated. This means that such radicals can be removed from the denominator of any 11 fraction, which maintains a constant variable format and makes mathematical operations easier to perform.

Conclusion

The modeling capabilities of matrices are useful for a variety of scientific studies. However, calculations using matrices are tedious and are completed quickly on a computer. Accuracy in these calculations can be maintained if a radical number format is used; values can remain in their exact form and there will be no rounding errors as would occur with a decimal- based system. Because of the amount of data that must be contained in a matrix, the program must have a system that allows easy entering of information. All functions that use the input data must be easily accessible from a menu network. A matrix calculator that can implement both the interface and the number type outlined above would be one of the most capable calculators of its kind. 12

Charter

Problem Statement: Free calculator apps rarely have all mathematical operations commonly used by students in college-level mathematics courses. Few existing apps that perform matrix calculations maintain numerical accuracy and an easy-to-use user interface. Solution: The goal of this project is to engineer an application that performs most matrix calculations used in college-level mathematics courses while maximizing computational accuracy and usability. 13

Materials and Procedure

Materials:

- Dell Inspiron 13-7378 laptop computer - Android Studios - IntelliJ IDEA Java IDE editor - Nexus 4 Android Device Emulator

Procedure:

A series of rational number-based matrix calculation programs were completed in Java code (see Appendix 1). Research was conducted to find a mobile device emulator that was free, available on a Windows device, and compatible with Java. Android Studios was selected as the preferred editor. Research was done on the attributes of a user interface to generate a list of its ideal qualities. Notes were taken on existing matrix calculators to list their qualities; these were sorted by positive or negative, depending on whether they were viewed as helpful or detrimental to the usability of the application. Data was taken to log the accuracy of each calculator by performing calculations that required the storage of repeating decimals in the matrix calculator systems. The decimal accuracy of each calculator was logged for comparison. Designs were sketched to incorporate the preferable attributes into the interface. As drafts of each design were created, the designs were coded into Android Studio interactive pages, starting with the homepage. The mathematical programs were assimilated into the interface code during s were programmed, and the prototype was tested for reliability. 14

Results

Table 2: Scoring matrix comparing four web-based competitor calculators and the basic Java interface with the mathematical code for PocketBrain.

Web Application Competitors

Weights Raw Java Desmos Reshish Wims BlueBit

Criteria

Highly accurate 3.0 3.0 2.7 3.0 3.0 2.4

Easy input design 6.0 1.2 2.4 4.8 4.8 4.8

Easy to export data 7.0 2.8 1.4 0.7 1.4 0.0

Easy to navigate 10.0 0.0 10.0 10.0 6.0 10.0

Highly forgivable 6.0 2.4 6.0 1.8 4.2 1.8

High number of

functions 4.0 3.6 2.0 2.4 2.4 4.0

Function variety 4.0 3.2 2.0 2.4 3.6 4.0

Highly capable of

variable storage 5.0 3.0 3.0 1.0 3.0 0.0

Clear explanation of

mathematical process 2.0 0.2 0.0 1.8 0.0 0.0

Available, organized

source code 3.0 2.4 0.0 0.0 0.0 0.0

Total 50.0 21.8 29.5 27.9 28.4 27.0

Percent 100 43.6 59.0 55.8 56.8 54.0

15 Table 3: Scoring matrix comparing four competitor mobile calculators.

Mobile Application Competitors

Weights PocketCAS MatrixCalc Matrix

Criteria

Easy to navigate 10.0 7.0 10.0 5.0

Easy to export data 7.0 4.9 0.0 0.7

Easy input design 6.0 1.8 1.2 4.8

Highly forgivable 6.0 4.8 1.2 4.2

Highly capable of variable

storage 5.0 2.0 1.0 3.5

High number of functions 4.0 1.2 2.0 1.6

Function variety 4.0 1.2 1.6 1.6

Available, organized

source code 3.0 0.0 0.0 0.0

Highly accurate 3.0 3.0 3.0 1.8

Clear explanation of

mathematical process 2.0 0.0 0.0 0.0

Total 50.0 25.9 20.0 23.2

Percent 100 51.8 40.0 46.4

16 Table 4: Scoring matrix comparing the four versions of PocketBrain.

Versions of PocketBrain

Weights 1 2 3 4

Criteria

Easy to navigate 10.0 5.0 10.0 10.0 10.0

Easy to export data 7.0 0.0 0.0 2.8 5.6

Easy input design 6.0 5.4 5.4 5.4 5.4

Highly forgivable 6.0 0.0 3.0 3.0 4.2

Highly capable of variable

storage 5.0 0.0 3.0 5.0 5.0

High number of functions 4.0 0.0 0.0 3.6 3.6

Function variety 4.0 0.0 0.0 3.2 3.2

Available, organized source

code 3.0 0.0 0.0 0.0 0.0

Highly accurate 3.0 3.0 3.0 3.0 3.0

Clear explanation of

mathematical process 2.0 0.0 0.0 0.0 0.0

Total 50.0 10.4 24.4 36.0 40.0

Percent 100 20.8 48.8 72.0 80.0

Among the programs listed in Table 2, any calculator received an automatic score of 10 for storing its variables in fractions, because this system of storage results in exact answers with no error. For Desmos and BlueBit, the decimal-based programs, they were further assessed on

the degree of magnitude of precision. Desmos was capable of recording values as small as ͳͲିଵ଼

ͳͲିଵହ to as low as ͳͲିଷ. 17 For input systems, Reshish, Wims, and BlueBit had the most flexible matrix input system; they each included an open text box to freely enter elements. However, the differences in length between the text strings in each matrix row caused shifting to occur that visually misaligned the elements in the input box. Any interface formation for the raw java file must be hardcoded; however, there are a few standardized input formats that can be added to the program. Desmos requires that the dimensions of the matrix be entered prior to adding elements. For data storage and exportation, the raw java file can convert matrices to readable character strings and store values if a method that can do so is coded. Desmos and Wims utilize storage but have maximum variable limits of less than 10 matrices. Reshish and BlueBit have no available storage. PocketBrain has virtually unlimited storage space and, because it uses the same code files as the raw java file, it can export the data in standardized strings. Desmos, Reshish, BlueBit, and PocketBrain contain single lists of all their available functions, either present on the main page of the application or available from there. The raw java file contains no programmable function menu. Wims has a list of computations but does not allow the user to access them all in its function list until after certain computations have been completed. The raw java and PocketBrain function menus feature basic operations, matrix inverses and their substeps, and a few extra programs. Desmos and Reshish consist largely of basic operation functions and system solution methods. Wims and BlueBit feature a larger number of decompositions on top of the programs available in the other competitors assessed. The only calculator ranked in Table 2 that explains the use behind its functions is Reshish. The java file can be reprogrammed to do so as well. No other assessed calculators have available code or mathematical function analysis. 18 The mobile calculators (see Table 3) and several versions of PocketBrain (see Table 4) were scored using similar systems. In each scoring matrix, the program with the highest overall ranking was highlighted green. Red highlighting on the total score and overall percentage marks the lowest scoring program, with all in between receiving yellow highlighting. 19

Conclusions

According to the data from Table 4 as compared to that from 2 and 3, PocketBrain has the largest overall score. Its performance in terms of accuracy, navigation system, and variable storage methods exceeded that of the other calculators. Higher individual attribute scores were achieved by other programs in only four areas: function quantity, function variety, clear explanation of process, and availability of source code. BlueBit slightly outperformed PocketBrain in quantity and variety by including several more decompositions and irrational number-based programs. However, its inability to store or export any type of data caused it to earn no points in either category. Reshish explained the general use of all its mathematical programs, but like BlueBit, it could not store data and lost points there as well (see results). The raw java file was the only program with available source code, but its lack of interface caused it to lose points in all categories that did not score specific functions and source code. One of the problems of the scoring system used in Tables 2, 3, and 4 was when considering numerical accuracy. Accuracy is the only attribute on the scoring matrix where one can get numerical results, by performing calculations and then calculating the deviation of each output value from the normal amount. Since this only looks at answers from each program and cannot account for the mathematical processes, this attribute is only weighed by the answer and may not model the true accuracy of the calculator. If the program produces exact results but shows only a rounded answer, its score is lowered, so the true accuracy of the calculator may not be represented. However, if this were the case, then the exact results stored in the program would be completely hidden from the user, which would justify its lowered accuracy score. 20 The other fundamental problem with the model was that the scoring was dependent on a single subjective view. Although there were some criteria that automatically raised, lowered, or automatically determined the ranking on any given attribute, the exact number was usually determined based on qualitative observations of calculator operation. This may not properly model the true rankings of each program because any given human tester may not be able to navigate or use PocketBrain as well as its creator, who assessed its capabilities. Thus, if weighted by other people, PocketBrain has the potential to receive a much lower usability score. For future development, PocketBrain could be recoded to incorporate an undo-redo forgivability system that allows users to revive old editions of their matrices or even old Matrix objects. This would allow the user to scroll back through their data history on the app and keep track of all the numbers they have used. Moreover, the EditMatrices page could be recoded to allow the user to reconsider deleting a matrix or resetting the app, which would prevent the user from accidentally deleting information with a misguided click. Other developments would extend the calculational limits of PocketBrain. Its current version does not have determinant and trace programs available from the function list. This is because the current version of the calculator can only store matrices and not individual numerical values, except in the form of a size-1 square matrix. A future extension of PocketBrain could include a separate storage system for handling scalar values such as the determinant and trace. 21

References

[A linear system set up to be solved by a matrix equality]. (2014, March). Retrieved November

28, 2018, from http://pklab.net/?id=380&lang=EN

Christensen, B. K. (2003). Matrix representation of a Neural Network. Technical University of

Denmark (DTU).

Gundlach, M. (n.d.). [A visual of the characteristic polynomial being formed given the input matrix.]. Retrieved November 28, 2018, from examples.html He, L., Shen, W., Li, Y., Shi, A., and Zhao, D. (2010) "MPI+OpenMP Implementation and Results Analysis of Matrix Multiplication Based on Rowwise and Columnwise Block- Striped Decomposition of the Matrices," 2010 Third International Joint Conference on Computational Science and Optimization, Huangshan, pp. 304-307. Ichimura, S., Katagiri, T., Ozaki, K., Ogita, T., and Nagai, T. (2018) "Threaded Accurate Matrix- Matrix Multiplications with Sparse Matrix-Vector Multiplications," 2018 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW),

Vancouver, BC, pp. 1093-1102.

Kerkez, B. (2000) (Dept. of Comput. Sci. & Eng., Wright State Univ., Dayton, OH, United States); Cox, M.T.; Srinivas, C. Source: Proceedings of the International Conference on Artificial Intelligence. IC-AI'2000, p 345-51 vol.1. Mario Pérez-Montoro, L. C. (2017). Navigation Design and SEO for Content-Intensive Websites.

Elsevier.

Oldenburg, H. (1989) "OSF Motif: the user interface standard," IEE Colloquium on User 22
Interface Management Systems, London, UK, pp. 2/1-2/8. Late 1970s and Early 1980s and the Social Networks Around Them." In IEEE Annals of the History of Computing (vol. 34, no. 3, pp. 55-66). Tate, H., Goto, S. and Takeuchi, S. (1996) "A proposal on content information management for multimedia service navigation system," Proceedings of NOMS '96 - IEEE Network Operations and Management Symposium, Kyoto, Japan, pp. 466-475 vol.2. Wang, S. and Dai, M. (2010) "The Generalized Inverse Inequalities for Symmetric Nonnegative Definite Matrices," 2010 International Conference on Artificial Intelligence and

Computational Intelligence, Sanya, pp. 547-550.

Appendices

Appendix 1: Acknowledgements

quotesdbs_dbs10.pdfusesText_16

[PDF] [PDF] pocketbrain: Matrix calculator application - WPI