Ops.freealg: Arithmetic Ops methods for the the free algebra

In RobinHankin/freealg: The Free Algebra

Arithmetic Ops methods for the the free algebra

Description

Arithmetic operators for manipulation of freealg objects such as addition, multiplication, powers, etc

Usage

## S3 method for class 'freealg'
Ops(e1, e2)
free_negative(S)
free_power_scalar(S,n)
free_eq_free(e1,e2)
free_plus_numeric(S,x)
free_plus_free(e1,e2)
lowlevel_simplify(words,coeffs)
lowlevel_free_prod(words1,coeffs1,words2,coeffs2)
lowlevel_free_sum(words1,coeffs1,words2,coeffs2)
lowlevel_free_power(words,coeffs,n)
lowlevel_diffn(words,coeffs,r)
lowlevel_subs(words1, coeffs1, words2, coeffs2, r)
inv(S)

Arguments

S, e1, e2	Objects of class freealg
n	Integer, possibly non-positive
r	Integer vector indicating variables to differentiate with respect to
x	Scalar value
words, words1, words2	A list of words, that is, a list of integer vectors representing the variables in each term
coeffs, coeffs1, coeffs2	Numeric vector representing the coefficients of each word

Details

The function Ops.freealg() passes binary arithmetic operators (“+”, “-”, “*”, “^”, and “==”) to the appropriate specialist function.

The caret, as in a^n, denotes arithmetic exponentiation, as in x^3==x*x*x. As an experimental feature, this is (sort of) vectorised: if n is a vector, then a^n returns the sum of a raised to the power of each element of n. For example, a^c(n1,n2,n3) is a^n1 + a^n2 + a^n3. Internally, n is tabulated in the interests of efficiency, so a^c(0,2,5,5,5,) = 1 + a^2 + 3a^5 is evaluated with only a single fifth power. Similar functionality is implemented in the mvp package.

The only comparison operators are equality and inequality; x==y is defined as is.zero(x-y).

Functions lowlevel_foo() are low-level functions that interface directly with the C routines in the src/ directory and are not intended for the end-user.

Function inv() is defined only for freealg objects with a single term. If x has a single term we have inv(x)*x=x*inv(x)=1. There is no corresponding division in the package because a/b may be either a*inv(b) or inv(b)*a.

Author(s)

Robin K. S. Hankin

Examples

rfalg()
as.freealg("1+x+xy+yx")  # variables are non-commutative
as.freealg("x") * as.freealg("X") # upper-case letters are lower-case inverses

constant(as.freealg("x+y+X+Y")^6)  # OEIS sequence A035610

inv(as.freealg("2aaabAAAAx"))

as.freealg("a")^(1:7)

RobinHankin/freealg documentation built on Dec. 24, 2024, 3:16 a.m.