SymbolicC++

SymbolicC++ is a general purpose computer algebra system written in the programming language C++. It is free software released under the terms of the GNU General Public License. SymbolicC++ is used by including a C++ header file or by linking against a library.

import"symbolicc++.h";
importstd;
usingnamespacestd;
intmain(){
Symbolicx("x");
std::println("{}",integrate(x+1,x));// => 1/2*x^(2)+x
Symbolicy("y");
std::println("{}",df(y,x));// => 0
std::println("{}",df(y[x],x));// => df(y[x],x)
std::println("{}",df(std::exp(std::cos(y[x])),x));// => -sin(y[x])*df(y[x],x)*e^cos(y[x])
return0;
}

The following program fragment inverts the matrix ${\displaystyle {\begin{pmatrix}\cos \theta &\sin \theta \\-\sin \theta &\cos \theta \end{pmatrix}}}${\displaystyle {\begin{pmatrix}\cos \theta &\sin \theta \\-\sin \theta &\cos \theta \end{pmatrix}}} symbolically.

Symbolictheta("theta");
Symbolicr={
{std::cos(theta),std::sin(theta)},
{-std::sin(theta),std::cos(theta)}
};
std::println(r(0,1));// sin(theta)
SymbolicrInv=r.inverse();
std::println(rInv[(std::cos(theta)^2)==1-(std::sin(theta)^2)]);

The output is

[ cos(theta) −sin(theta) ]
[ sin(theta) cos(theta) ]

The next program illustrates non-commutative symbols in SymbolicC++. Here b is a Bose annihilation operator and bd is a Bose creation operator. The variable vs denotes the vacuum state ${\displaystyle |0\rangle }${\displaystyle |0\rangle }. The ~ operator toggles the commutativity of a variable, i.e. if b is commutative that ~b is non-commutative and if b is non-commutative ~b is commutative.

import"symbolicc++.h";
importstd;
intmain(){
// The operator b is the annihilation operator and bd is the creation operator
Symbolicb("b");
Symbolicbd("bd");
Symbolicvs("vs");
b=~b;
bd=~bd;
vs=~vs;
Equationsrules=(b*bd==bd*b+1,b*vs==0);
// Example 1
Symbolicresult1=b*bd*b*bd;
std::println("result1 = {}",result1.subst_all(rules));
std::println("result1 * vs = {}",(result1*vs).subst_all(rules));
// Example 2
Symbolicresult2=(b+bd)^4;
std::println("result2 = {}",result2.subst_all(rules));
std::println("result2 * vs = {}",(result2*vs).subst_all(rules));
return0;
}

Further examples can be found in the books listed below.^{[1] [2] [3] [4]}

SymbolicC++ is described in a series of books on computer algebra. The first book^[5] described the first version of SymbolicC++. In this version the main data type for symbolic computation was the Sum class. The list of available classes included

• Verylong: An unbounded integer implementation (like BigInteger)
• Rational: A template class for rational numbers
• Quaternion: A template class for quaternions
• Derive: A template class for automatic differentiation
• Vector: A template class for vectors (see vector space)
• Matrix: A template class for matrices (see matrix (mathematics))
• Sum: A template class for symbolic expressions

Example:

import"rational.h";
import"msymbol.h";
importstd;
intmain(void){
Sum<int>x("x",1);
Sum<Rational<int>>y("y",1);
std::println("{}",Int(y,y));// => 1/2 yˆ2
y.depend(x);
std::println("{}",df(y,x));// => df(y,x)
return0;
}

The second version^[6] of SymbolicC++ featured new classes such as the Polynomial class and initial support for simple integration. Support for the algebraic computation of Clifford algebras was described in using SymbolicC++ in 2002.^[7] Subsequently, support for Gröbner bases was added.^[8] The third version^[4] features a complete rewrite of SymbolicC++ and was released in 2008. This version encapsulates all symbolic expressions in the Symbolic class.

Newer versions are available from the SymbolicC++ website.

• Comparison of computer algebra systems
• GiNaC

• Official website
• Programming exercises in SymbolicC++

• Free computer algebra systems
• Free software programmed in C++
• C++ libraries

• Articles with short description
• Short description matches Wikidata
• Official website different in Wikidata and Wikipedia
• Articles with example C++ code