Details for this torrent 

Brieda L. Introduction to Modern Scientific Programming...Numerical Methods 2024
Type:
Other > E-books
Files:
12
Size:
490.98 MiB (514831838 Bytes)
Uploaded:
2024-09-06 12:52 GMT
By:
andryold1
Seeders:
55
Leechers:
25

Info Hash:
35C0337AAF2031FE8DA381BA0A9BB65D2F7FAEF3




Textbook in PDF format

The ability to use computers to solve mathematical relationships is a fundamental skill for anyone planning for a career in science or engineering. For this reason, numerical analysis is part of the core curriculum for just about every undergraduate physics and engineering department. But for most physics and engineering students, practical programming is a self-taught process.
This book introduces the reader not only to the mathematical foundation but also to the programming paradigms encountered in modern hybrid software-hardware scientific computing. After completing the text, the reader will be well-versed in the use of different numerical techniques, programming languages, and hardware architectures, and will be able to select the appropriate software and hardware tool for their analysis.
It can serve as a textbook for undergraduate courses on numerical analysis and scientific computing courses within engineering and physical sciences departments. It will also be a valuable guidebook for researchers with experimental backgrounds interested in working with numerical simulations, or to any new personnel working in scientific computing or data analysis.
Key Features:
Includes examples of solving numerical problems in multiple programming languages, including MatLAB, Python, Fortran, C++, Arduino, JavaScript, and Verilog.
Provides an introduction to modern high-performance computing technologies including multithreading, distributed computing, GPUs, microcontrollers, FPGAs, and web "cloud computing".
Contains an overview of numerical techniques not found in other introductory texts including particle methods, finite volume and finite element methods, Vlasov solvers, and molecular dynamics.
Preface
Author Bios
Scientific Computing Basics
Introduction
Numerical Integration
Scientific Computing
Programming Languages
Machine Language
Compiled and Interpreted Languages
Example Algorithm
Fortran
BASIC
Pascal
C and C++
Java
MatLAB
Julia
R
Haskell
Others
Python Implementation
File Output
Arrays and Plotting
List Initialization
NumPy Arrays
For-Loops
Conditional Statements
Functions
Random Numbers
Code Validation
Leapfrog Method
Finite Difference and Linear Algebra
Taylor Series
First Derivative
Second Derivative
Finite Difference Discretization
Boundary Conditions
System of Equations
Gaussian Elimination
Matrix Representation
Matrix Algebra
Matrix Inverse
Matrix Types
Matrix Solvers
Solver Algorithms
Gauss-Jordan Elimination
Python Implementation
Tridiagonal Algorithm
Iterative Solvers
Jacobi Method
Gauss-Seidel Method
Convergence Check
Successive Over Relaxation (SOR)
D Heat Equation Solver
Sparse Matrix
Putting it all together
Iterative Solver Version
Numerical Analysis
Data Fitting
Polynomial Fits
Spline Fits
Least Squares Fit
Fourier Series
Filtering
Probability Distributions
Quadrature
Root Finding
Additional Matrix Solver Algorithms
Multigrid
Conjugate Gradient
LU and Cholesky Decomposition
Eigenvalues
Non-Linear Systems
Poor Man’s Linearization
Newton-Raphson Linearization
Introduction to C++
C and C++ Basics
Compilers and Development Environments
Main Function and Basic Code Structure
Variables
Comments and Preprocessor Directives
Functions
Header Files
Data Types
Strings
Floating Point Mathematics
Integer Division
Stream Input and Output
Variable Scope
Static Variables
Conditional Statements
Enumerations
Conditional Operator
Loops
Arrays and Dynamic Memory Allocation
Exceptions
C++ Tennis Ball Integrator
Initial Version
Diffuse Reflection
Random Numbers
Updated Version
Visualization
VTK PolyData Format
Structures
Pointers and References
Pointer Arithmetic
References
Call by Reference
Constant Arguments
Multi-Dimensional Arrays
Linked Lists
Object Oriented Programming
Constructors and Destructors
Initializer Lists
Access Control
Friends
Operator Overloading
Copy and Move
Static Member Functions and Namespaces
Inheritance and Polymorphism
Templates
Storage Containers
Smart Pointers
Lambda Functions and Functors
Heat Equation Solver in C++
Storage Objects
Matrix Solver
VTK ImageData Output
Main Driver
Kinetic Methods
Introduction
Thermalization
Flow Properties
Knudsen Number
Kinetic Methods
Eulerian and Lagrangian Formulation
Reduced Dimensionality
Free Molecular Flow
Particle Storage
Computational Domain
Initialization
Sources
Main Loop
Particle Push
Particle Removal
Steady State
Mesh-Averaged Properties
Results
Collisions
Monte Carlo Collisions
Direct Simulation Monte Carlo
Particle in Cell
Lorentz Force
Electrostatics
Integration Algorithm
Hybrid Modeling
Sugarcubing
Initialization
Implementation
Eulerian Methods
Introduction
Advection-Diffusion Equation
Diffusion Equation
PDE Classification
Advective Term
Integration Schemes
Forward Time Central Space (FTCS)
Von Neumann Stability Analysis
Predictor-Correct Method
Multipoint Methods
Runge-Kutta Methods
Leapfrog and Dufort-Frankel Methods
Euler Implicit Method
Crank-Nicolson Method
Vorticity-Stream Function Method
Stream Function
Vorticity Transport Equation
Boundary Conditions
Implementation
Vlasov Methods
Implementation
Initial Conditions
Simulation Main Loop
Electric Field
Interpolation
Visualization
Other Model Equations
First-Order Wave Equation
Diffusion Equation
Burger’s Equation
Maxwell’s Equations
Finite Volume Method
Surface Integral: Advection
Surface Integral: Diffusion
Combining Terms
Axisymmetric Formulation
Interactive Applications
HTML
Common Elements
Styles
Classes and Ids
Dynamic Web Pages
JavaScript
Developer Tools
Syntax
Mathematics
Arrays and Objects
Object-Oriented Programming
Accessing HTML Elements
Animation
Canvas
User Interaction
Keyboard and Mouse Interaction
Adding Dynamics
Colormap
File Access
XMLHttpRequest
External JavaScript Files
File Input Button
Drag and Drop
File Output
WebGL
Shader Program
Shaders
Drawing Elements
Attributes, Varyings, and Uniforms
Textures
Software Engineering
Debugging
Common Errors
Print Statements
Debuggers
Command Line Debugging
Memory Leaks
Large Projects
Make Files
Configuration Scripts
Libraries
Useful Libraries
BLAS and LAPACK
PETSc
OpenFOAM
VTK
Boost
Cython
Graphical User Interface Frameworks
Coding Standards
Code Testing
Verification and Validations
Uncertainty Analysis
Sensitivity Analysis
Convergence Studies
Version Control
Unit Testing
Code Documentation
LaTeX
Sections and References
Environments
Equations
Bibliography
High-Performance Computing
Introduction
Serial Optimization
Profiling
Algorithm Modification
Code Optimization
Cache Misses
Parallel Processing
Multithreading
Thread Creation
Parallel Vector Addition
Parallel Efficiency
Threads with Classes
Dot Product
Locks and Mutexes
Atomics
Message Passing Interface (MPI)
MPI Dot Product
Send and Receive
Deadlock
Reduction
Domain Decomposition
Remote Access
Parallel Debugging
CUDA
Online Computational Resources
Vector Addition
Error Checking
Blocks
Timing
Pinned Memory
Streams
Dot Product
Concurrent MPI-CUDA Computation
Visualization
Optimization and Machine Learning
Introduction
Cost Function
Optimization Approaches
Adaptive Search
Gradient Descent
Examples
Genetic Algorithms
Machine Learning
Neural Networks
Activation Functions
Cost Function
Back Propagation
Simple Neural Net in C++
Libraries
Embedded Systems
Single-Board Computers
Microcontrollers
Electrical Components
Breadboards
Arduino Programming
Pin Interactions
Using Libraries
Interfacing with Python
Custom Libraries
FPGAs and Verilog
Development Environments
FPGA Hello World
Schematic View
Events
Data Types and Assignments
Clocks
Control Statements
IP Blocks
Simulation
FPGA Synergistic use with an Arduino
Appendix A: Fortran Syntax
References
Index