This package has a lot of programs for interpolation and fitting data. This one provides to you the possibility to make the tests in short time and with all explanations. This package has programs like spline and Lagrange interpolation. Fits data with hyperbolic and trigonometric fit.
Performs approximate integration, the area under the curve described by a set of points, polynomial regression with graphic, multiple linear regression, differential equations, and finite difference.
Calculates the approximate definite integral for a given function using one of the following five methods: Midpoint Rule, Left Endpoint Rule, Right Endpoint Rule, Trapezoidal Rule, or Simpson's Rule.
Takes an integer as input and returns the Roman representation in Arabic numerals, using OEIS A093788. For example, given 1953, otherwise known as MCMLIII, the program returns 1000100100050111, which is the letter by letter, left to right, value of the Roman letters.
Provides the Bessel functions J,Y,I and K of integer order and for real arguments. Also handles the beta function, the incomplete beta function, associated Legendre polynomials, and spherical harmonics.
Difference tables and the binomial transform are powerful methods for analyzing integer sequences and their underlying logic. See also Conway and Guy, "The Book of Numbers", chapter 3. Difference tables can be easily created using the \GDLIST (Delta-LIST) command on many HP calculators. This directory contains a program to return a difference table as a list of lists, the inverse binomial transform of a list, and the binomial transform of a list. Also has a program to do OEIS A000292.
Implements the boustrophedon transform for a list of integers, OEIS A000111 and the triangle associated with the transformed sequence, OEIS A008280. Requires GoferLists.
The Champernowne sequence (OEIS A030190) is a natural number sequence concatenated in binary & split into single digits: 0,1,1,0,1,1,1,0,0......... This program returns the specified element of the series.
Global root solver, minimum and maximum via Chebyshev expansions. Uses a custom parser in C, and recursively solves for all roots via eigenvalue solving of the (implicit) companion matrix. Uses a fast experimental solver. Has some utilities for Chebyshev transformation, fast parser, plotter and various FFT transformations and CDT included in the library. Parses and solves a Chebyshev expansion of size 129 in about 1 second. Can handle Chebyshev expansions up to 1025. Does not work on a regular calculator; requires a custom HPGCC ROM on a 50g to run.
Generalizations of the method used to create Pascal's triangle and similar number triangles, containing two programs. The first program takes a list of integers and returns the transformed list, which will be one term longer than the input list. The next program implements the ConvOffsStoT transform. It calls the program above. This program is basically the same but returns a list of lists which are transforms of sublists of the input list. Given a list of length n, the program will return lists of length 1 through n+1.
This library have a very useful program that allows you make the translations between spherical, cylindrical and rectangular coordinates easily. Very useful in Electrical Engineering.
A program to numerically approximate differential equations. It was written for educational/illustration purposes and features 3 methods: Euler's Method, modified Euler's Method, and RK4 (4th-order Runge-Kutta). All steps are output to the stack.
Basic real number and matrix (multiplication , addition, solving, determinant) arbitrary floating point precision using hpgcc and decNumber library. Requires the 49g+ or 50g, ARM ToolBox and LongFloat library. Faster than standard HP for 16 digits precision.
Delannoy numbers have many applications in combinatorics and number theory. Fortunately they are fast and easy to compute. These programs return a rectangular array of Delannoy numbers, the Delannoy triangle (also known as the tribonacci triangle), and the central Delannoy numbers. The first one requires GoferLists and only runs on the 49/50; the latter two also run on the 48.
Differential Equations - Explicit Runge-Kutta methods of order 4, 8 & 10 and Implicit Runge-Kutta methods of order 12 & 13. Gravitational n-body problem solved by RK4, RK8, RK10 and the built-in RKF (except 48S/SX).
Comprehensive package with routines to calculate curl, divergence, gradient, Laplacian (rectangular, cylindrical and spherical coordinates), Hessian matrix, biharmonic and triharmonic operators, curvature and torsion of a curve, curvature(s) of a surface and a hypersurface, and Riemannian geometry, for metric tensor, Christoffel symbols, curvature tensor, Ricci tensor, Einstein and Weyl tensors and a few tensors in non-Riemannian manifolds. Also works with complex manifolds. Includes detailed documentation in HTML format explaining all commands.
Contains four programs: DIVIS.G (tells how many divisors a number has and which are they, with nice input form), DIVIS.S (same thing, but without interface, less intuitive but faster), FATOR.G (factorizes a number/decompose it into prime numbers, with nice input form) and FATOR.S (same thing, but without interface, less intuitive but faster).
First release of a library containing a set of extra functions for the HP 49g+ only. 30 functions are included in this release, including additional trigonometric functions (COT, COTH, SEC, SECH, SINC etc.), number theory functions (Fibonacci and Lucas etc.) as well as much faster replacements of the built-in factorial and combinatorial functions. The library is mainly coded in C to maintain high performance and efficient memory management.
This program calculates the exact factorial of an integer. While the HP 49g+ has this built in, this program runs roughly forty times faster. 1000! takes FFAC about .35 seconds to calculate. The built in routine takes 27.5 seconds. FFAC runs natively on the ARM CPU. This is the first such user-made program for the 49g+. This program shows what the 49g+ is capable of when running native code. For the 49g+ only!
Fast Fibonacci calculates exact terms from the Fibonacci series very quickly. The 9999th term takes about 2 seconds to calculate with just over 2 thousand digits. This is for the 49G+/48GII only as it was written in C and uses the ARM CPU.
Calculates the GCD of two integers much faster than the built-in routine. Includes separate versions optimized for the different characteristics of the 49G and 50g.
The built in integer square root-finder function returns the integer square root of N a positive integer and TRUE/FALSE if the square of the answer is exactly N or not. Sadly the square root of larger integers is not calculated correctly. This program returns the correct value.
Very fast System RPL functions for calculating the full integer values of Fibonacci Numbers, Lucas Numbers, and other Generalized Fibonacci recursive sequences. Source code, help text, and algorithm details included.
Small program that allows you to find critical points, gradient, and Hessian of a 2 or 3 variable function. Very useful for mathematical analysis students. Completely written in User RPL.
This program is useful for converting a decimal number to a floating point number. With this program you can find the bias and the epsilon of a hypothetical machine as well as get the standard floating point notation of any number based on IEEE 754. You can also obtain non standard notations.
Fast plotter and numerical integrals and sums of algebraic expressions using hpgcc2. Speed is 50 to 100x faster than User RPL. Sums from 1 to 100,000 in about 1 second. For the 50g and 49g+ only. Runs in RPL with stack entry mode. SD card is required (takes 80KB on the card). Full C-source is included
Small program which allows you to do numerical integration, with numbers lists and functions. It has been written in User RPL under the 1.18 ROM. Great utility for engineers.
Program for numeric methods. Solves linear interpolation. Designed for students of Chihuahua Tech studying engineering. Messes with your calculator's settings.
User RPL library for making linear interpolation, both simple and double. Allows INFORM interpolating, as well as STACK interpolating, the latter one quite quickly.
For integer input N, K, this program returns the corresponding Lah number. Lah numbers are coefficients expressing rising factorials in terms of falling factorials.
This program works with the limit of two variables in calculus, making the iterator limit (the limit of one variable of the limit of the other variable).
System RPL and machine language library with linear- tabular- and double interpolation, cubic splines, linear predicting, and second and third order least squares polynomial fitting. Accepts many combinations of input. Also tested on 49g+ ROM 1.23.
Asks you to input equations (even fractions), as long as you enter the same number of equations as there are variables. Then it shows you the equations again, in order for you to check them out and see if you typed them right. The program can then either put the results on the stack or send you to the matrix editor so you can fix the equations.
Multiple precision real and complex library including trig and hyperbolic functions. Interval arithmetic (precision tracking) for real functions. Algebraics with interval numbers or units may be automatically evaluated to user-defined precision. Now has basic matrix functions and 49g+/50g support.
Numerical Methods at Universidad Técnica Particular de Loja, Ecuador. This is a very simple program to use. It contains Newton-Rapson's method, Euler, Runge-Kutta and a method to calculate the deflection of a beam by a finite difference.
Yet another numeric methods program. Spanish-speaking people seem to like creating these. At least this one is relatively compact. Works for Bisection, Fixed Point, Newton Raphson, second order Newton Raphson, and secante. Written in User RPL.
This file contains 23 programs for numerical methods: bisection, fixed point, Newton, secant, false position, Steffense, Muller, Lagrange, Neville, Gausseidel, Jacobian, fixed point and Newton for systems of equations, Fourier series, Richardson, numeric differentiation, trapezoidal, Simpson, Romberg, Gaussian square, Euler, RKR, and higher order Taylor.
This is a program for fluid mechanics; it contains three cases, you should input certain data and then it calculates the loss of pressure, the flow or the diameter. Written for use at the Universidad Técnica Particular de Loja, Ecuador.
Minimax polynomial approximation, which minimizes absolute error (not RMS). Can be used to fit data as well as functions. Implemented in User RPL, System RPL, hpgcc2 and hpgcc3 for comparison to Valentin's original implementation in HP-71 BASIC.
Three Moebius transform related programs. They are most useful for integer sequences related to the divisor function, the Moebius Mu function, and the Euler Phi function. Requires ListExt.
Non-negative least squares solves least squares problems subject to all results being greater or equal to 0. Possible to use result limits different from 0. Programmed in hpgcc. For the 49g+ or 50g only. Also includes freestanding version not requiring armtoolbox.
Implementations of some commands from the Wolfram Language, including a command to generate a list of integers based on the linear recurrence of the integer sequence, and two commands to perform convolution of lists, one of which takes a list and a kernel, and the other which takes two lists, plus a command for deconvolution, plus commands for the convolution inverse and convolution square root. Requires ListExt for the first two programs; only the last two run on the 48 as well.
A fast numerical library, containing real and complex numerical solvers, substitution and numerical evaluation tools and a fast numerical integration command. Documentation in HTML and Word 2000 formats.
The NWT program can solve linear and nonlinear systems of equations using the Newton method. For this it is necessary to calculate the Jacobian matrix which the program does with a symbolic method.
For a given natural number input N, this returns the Nth element of a triangle where all numbers are odd, with the leftmost digit being 2 greater than the one above it and each digit to the right being 2 greater than the one before. This is OEIS A131421.
Two programs, one which computes the outer product of two vectors or the Kronecker product of two matrices, and the other which computes the "generalized outer product" of two vectors.
Given an integer n on the stack, these two programs return a list of the partition numbers (A000041) from 0 through n. The first program is small, and the second one is fast. Also has a third program that returns the partition number triangle (A008284) as a list of lists. It is large (214 bytes) but fast, as it takes advantage of many patterns that occur in the triangle.
This program converts a numeric value in coordinated rectangular to coordinated polar (cylindrical) and vice versa. Also shows the formulas used in the calculation.
Program for solving eigenvalues and vectors problems with the "potencias" method. It includes a program that allows you to find the eigenvalues and vector of the inverse matrix. Very handy for students in numeric methods class. All written in RPL.
For a given integer input N, this returns the Nth integer of the series where the elements are all numbers in naturally ascending order whose product of digits is a prime. This is OEIS A028842.
Allows you to choose to calculate any one side of a right triangle, or enter all of the side lengths of a triangle to find if it is right. In User RPL for easy editing and compatibility with the 49 and 48.
A User RPL program to calculate the vertex, roots, discriminant, and completed square [or standard form] of a quadratic equation using given coefficients. Gives exact values (on the HP 49 only) if desired.
Calculates the radial spectrum of a square matrix. Useful for numeric methods for solving a linear system via iterative methods (Jacobi, Gauss-Seidel, or SOR).
Set of three User RPL programs to compute the Ramanujan tau function (A000594) for positive integers. Requires Sum of Divisors to an Integer Power and ListExt. Also includes a standalone program written in System RPL.
Asks you for an input (decimals or fractions) and calculates the center of a rectangle, switches from general to particular equation of a rectangle and vice versa, finds the slope of a rectangle, given 2 points, finds the distance between 2 points, finds the shorter distance between a rectangle and a point, finds the equation of a rectangle, given a point and the slope, and finds the equation between 2 points.
In recreational mathematics, a repunit is a number like 11, 111, or 1111 that contains only the digit 1 — a more specific type of repdigit. This assembly language program generates the nth repunit very quickly.
A couple of programs for solving differential equations by the Runge Kutta method. It allows you to solve problems by using Euler's method and also Runge Kutta's second order methods. Very useful for calculus students in the Universidad Nacional de Cuyo and for any numeric method student. Written in User RPL for all 49/50 series models.
A program that uses the shoelace method for calculating the area of a polygon (3 different versions, including one that runs on both the 48 and 49) and another version that also calculates the area and centroid (barycenter) of a polygon (for the 49 only). Also calculates the perimeter of a polygon.
This is a set of some simple quadratic tools that solve quadratics for x and y, finds the roots and the discriminant, completes the square, finds the vertex, and finds a curve.
SLK (Straight Line Kit) is a User RPL program specially focused on the straight line. It helps you to find the graph of a straight line, the slope between two points, the distance between two points, the middle-point coordinates, the perpendicular distance between a point and a straight line, the equation of a straight line that goes through a point with a slope, the equation of a straight line between two points, the (x) & (y) intercepts of a straight line, and the intersection point of a system of 2 linear equations, plus it will transform linear equations back and forth between standard and slope-intercept forms. Also includes a help section. Works on the 50g and the 49g+.
Tiny MSLV (multiple equation solver) for all RPL calculators. Program is 333.5 bytes on the 48GX. On the HP-28C it can find a simultaneous root of five nonlinear real-valued expressions. Uses successive approximation and the calculator's built-in matrix functions.
Multiple root polynomial solver, (approximate) polynomial GCD, polynomial division together with fast matrix solver, eigenvalues, least square solver and SVD decomposition. Programmed in hpgcc. Solves 50x50 matrix in less than 5 sec. Requires ARM ToolBox and a 49g+ or 50g.
These libraries allow you to perform arithmetic with numbers to a precision defined by you. Just store a number (long integer or real) into a global or local variable DIGITS, and use any of the new commands to create and work with the variable precision numbers.
Takes integer input from the stack and returns the labelled lengths of the prodromic and periodic parts of the verbal description of the input and the descriptions of the input to the stack.
A collection of small programs that are useful for Calculus: Graph Integrals, Riemann Summs, Trapezoid Rule, Simpson's Rule, Simpson's 3/8 Rule, Monte Carlo Integration, Newton's Method, Method of Bisectors, calculate arclengths, error function.
This a library that contains four numeric methods. These methods are useful for finding roots of any expression. The methods are: bisection, Regula Falsi, fixed point and Newton-Raphson. The result is given in the stack, and every step that the method did to find the root is presented in a matrix. This matrix is stored in the current directory with the name: "Tabla". Messes with your calculator's settings.
Set of two programs for zigzag numbers. One returns a list of the zigzag numbers (A000111) from 0 though n. The even-indexed terms (starting with 0) of the list are the unsigned Euler numbers, also known as secant numbers (AA000364). The odd-indexed terms (starting with 1) are the tangent numbers, AA000182. The other returns rows 0 through n of AA008281, the triangle from which the zigzag numbers are derived. Requires GoferLists.