دانلود کتاب ریاضیات نمادین با پایتون

The goal of this book is to give a hands-on approach to computer symbolic computation using elementary commands of Python. The book treats the symbolic manipulation of expressions involving rational functions, logic statements, and the exact fractional solutions of systems of linear equations. The book also contains a variety of applications, including symbolic differentiation and integration. A module with immediately runnable code is available on GitHub for each chapter, allowing the reader to experiment with, modify, or build upon the programs. Numbers used in computer numerical computations are typically floating point numbers or integers, both of which are restricted in size due to the computer’s lack of ability to represent some numbers exactly. This results in rounding errors, which may accumulate during run time, a serious defect in some areas of scientific computing, where exact answers may be needed. Symbolic computation provides exact results, with numbers written as exact fractions and variables processed symbolically. Of course, fractions may eventually need to be approximated by decimal values, but delaying this conversion until the end avoids accumulation of errors and so results in better approximations. The field of symbolic computation can be quite abstract, delving deeply into the study of algorithms that manipulate mathematical expressions. There are sophisticated software products, for example Mathematica and Maple, that perform complex symbolic computations based on these algorithms. Such commercial products also have extensive graphics capabilities. Additionally, there are computer languages, including Python, with packages that perform some symbolic computations. How then does this book fit into field of symbolic computation? First, here’s what it isn’t: It is not a book on abstract symbolic computation algorithms. Nor is it a book on how to use commercial products or computer language packages that implement these algorithms. Indeed, there are excellent books and manuals that fulfil these functions. Rather, the goal of this book is to give a coding approach to symbolic computation using elementary commands of Python. In light of the availability of commercial packages, the reader might reasonably ask, “Why bother?”. It’s a good question, particularly for those whose interests lie in end results for applications. But for those interested in how some of these results may be achieved, the book may have some relevance. The author is quick note that he does not have any insight into the proprietary code of commercial products. However, many aspects of symbolic computing can be analyzed and then implemented as Python programs in a natural and straightforward way. We have attempted to do this in the book. Of course, the programs developed here do not pretend to compete with professional software packages, these usually being the efforts of teams of mathematicians and programmers and requiring considerable time to develop. Nevertheless, it is hoped that the methods in the book will give the reader some insight into concrete symbolic computer mathematics at an elementary level. The book is organized as follows. Chapter 1 provides the basic concepts of Python needed to develop the modules in the book. The chapter is anything but encyclopedic. Excellent manuals are available that discuss in detail the multitude of features in Python. The chapter is meant to get the reader off and running with as few coding frills as possible. The module associated with this chapter is Essentials.py. Chapter 2 collects together many of the common tools required by the programs in the book. These are primarily concerned with scanning mathematical expressions, retrieving various symbols, and inserting symbols into these expressions. The module associated with this chapter is Tools.py. Chapter 3 develops programs that generate truth tables from expressions involving logical operators and, conversely, programs that generate such expressions from truth tables. The module associated with this chapter is Logic.py. Chapter 4 develops some elementary number theory, including the division algorithm, the greatest common divisor, prime numbers, congruences and modular arithmetic. One of the main functions here expands a positive integer into a product of primes, giving concrete illustrations of the Fundamental Theorem of Arithmetic. The module associated with this chapter is Number.py. Chapter 5 constructs a module that simplifies arithmetic expressions involving integers and complex fractions, providing exact results. The main function is the underpinning of subsequent symbolic algebra and calculus programs. A new cipher based on the program is given as an application. The module associated with this chapter is Arithmetic.py. Chapter 6 develops a module that does one-variable symbolic polynomial algebra. Applications are made to polynomial calculus and interpolation. The module associated with this chapter is PolyAlg.py. Chapter 7 continues the theme of the preceding chapter, developing programs that extract rational roots and factors from polynomials. The module associated with this chapter is PolyDiv.py. Chapter 8 generalizes the module in Chap. 6 to rational expressions in several variables. Applications are made to multivariable calculus, including a program that symbolically calculates partial derivatives of multivariable rational functions and one that generates Taylor polynomials in two variables. The module associated with this chapter is MultiAlg.py. Chapter 9 is the first of a sequence of chapters devoted to symbolic linear algebra. The first half of the chapter develops a program that generates the reduced row echelon form of a matrix with rational complex entries. The second half uses the echelon form to construct exact symbolic solutions of systems of linear equations. The module associated with this chapter is LinSolve.py. Chapter 10 develops programs that manipulate matrices algebraically, including a matrix calculator that produces symbolic results. An application to curve fitting is given. The module associated with this chapter is MatAlg.py. Chapter 11 develops programs centering around linear independence of vectors. The main results concern the range and kernel of a matrix. The module associated with this chapter is Vectors.py. Chapter 12 constructs programs that symbolically evaluate determinants. Applications include a symbolic version of Cramer’s rule as well as some geometry. A final application generates the inverse of a matrix with rational function entries. The module associated with this chapter is Determinants.py. Chapter 13 generalizes the main program in Chap. 8 by allowing expressions that contain not only variables but also parameters. The main function is used to construct a program that outputs the partial fraction decomposition of a rational function. The module associated with this chapter is MultiAlgParams.py. Much of the mathematics in the book is self-contained, although details are often omitted, the emphasis being on coding. The material is easily accessible to readers with a background in basic calculus and linear algebra.