MathAction changed pages

[FriCAS Library Examples]

Mon, 02 Mar 2026 18:19:05 +0000

++added: ExampleTrigonometricConstants

[ExampleTrigonometricConstants]

Mon, 02 Mar 2026 18:17:05 +0000

??changed: - Example of computations with trigonometric constants Consider the problem: Let $t := (5/9)\pi$. Simplify $tan(t) + 4sin(t)$. We can solve it by noting that involved numbers can be expressed in terms of roots of $1$, Namely, first we express trigonometric functions in terms of complex exponentials. Since $(5/9)\pi$ is a rational multiple of $\pi$ we get root of $1$, in this case root of degree $18$. But we also need $i$, which leads to root of degree $36$. Corresponding field is extention by cyclotomic polynomial, so we build it: \begin{axiom} cyclotomic(36)$CyclotomicUtilities )set output algebra on )set output tex off cF := SAE(FRAC(INT), SUP(FRAC(INT)), %) )set output tex on )set output algebra off \end{axiom} Now, we can express all ingredients in terms of generator: \begin{axiom} et := (generator()$cF)^10 ct := (et + 1/et)/2 st := (et - 1/et)/(2*(generator()$cF)^9) \end{axiom} and our expression is: \begin{axiom} ex := (4*ct + 1)*st/ct \end{axiom} Now we can find minimal polynomial and find its roots: \begin{axiom} minimalPolynomial(%) \end{axiom} and we see that the result is $\sqrt(3)$. We could also observe that the expression above is a member of smaller cyclotomic field and from that infer expression $2\cos(\pi/6)$. Consder now expression $$ i(5\sin((5\pi)/7)-5\sin((4\pi)/7)+5\sin((3\pi)/7) -5\sin((2\pi)/7)) -5\cos((5\pi)/7)+5\cos((4\pi)/7) $$ $$ -5\cos((3\pi)/7)+5\cos((2\pi)/7) -10\cos(\pi/7)+6. $$ Now we need root of $1$ of degree $28$, so we build the field: \begin{axiom} cyclotomic(28)$CyclotomicUtilities )set output algebra on )set output tex off cF2 := SAE(FRAC(INT), SUP(FRAC(INT)), %) )set output tex on )set output algebra off \end{axiom} Root of degree $4$ that is generator to power $7$ gives us imaginary unit $i$, Suare of generator gives us primitive root of degree $7$, that is $\exp(\pi/7)$: \begin{axiom} im2 := generator()$cF2^7 e1 := generator()$cF2^2 \end{axiom} We express trigonometric functions in terms of this \begin{axiom} c1 := (e1 + 1/e1)/2 e2 := e1^2 c2 := (e2 + 1/e2)/2 s2 := (e2 - 1/e2)/(2*im2) e3 := e1^3 c3 := (e3 + 1/e3)/2 s3 := (e3 - 1/e3)/(2*im2) e4 := e1^4 c4 := (e4 + 1/e4)/2 s4 := (e4 - 1/e4)/(2*im2) e5 := e1^5 c5 := (e5 + 1/e5)/2 s5 := (e5 - 1/e5)/(2*im2) \end{axiom} Using this we can compute the expression: \begin{axiom} im2*(5*s5 - 5*s4 + 5*s3 - 5*s2) - 5*c5 + 5*c4 - 5*c3 + 5*c2 - 10*c1 + 6 \end{axiom}

[ExampleFreeModule]

Fri, 27 Feb 2026 08:25:13 +0000

??changed: - How to use FreeFreeModule Commit https://github.com/fricas/fricas/commit/e5785c16bf7552522aac47ab5bb698244bffe090 removed the domain FreeAbelianGroup from FriCAS. See also https://groups.google.com/g/fricas-devel/c/yYgfAC-KWhg/m/p23BP5ZSBQAJ . It can be replaced by FreeModule as follows. \begin{axiom} )version Z ==> Integer FreeAbelianGroup X ==> FreeModule(Integer,X) A ==> FreeAbelianGroup(M) M ==> Matrix Z m1 := matrix [[1,2],[3,4]] m2 := matrix [[8,3]] m3 := matrix [[6],[7]] a1 := m1::A; a2:=m2::A;a3:=m3::A; x1 := 2*a1+a2 x2 := 3*a1-5*a3 x1+x2 \end{axiom}

[Symbolic Integration]

Wed, 23 Jul 2025 14:26:04 +0000

??changed: -Unfortunately, due to a bug during final processing this result got mangled and elliptic -integral part is dropped, giving wrong result. - -We gets correct result when we keep only algebraic part Below is result when we keep only algebraic part

[ExpressionInteger]

Mon, 12 May 2025 13:08:44 +0000

++added: Consequently, expressions which mathematically have the same value may be different as elements of 'Expression(Integer)'. Actually, arithmetic in 'Expression(Integer)' is automatically doing algebraic simplifications, but otherwise treats quantities as independent. ??changed: -For more specialized domains like 'DMP([a,b], Integer)', Technically, expression above is an algebraic relation between transcendental quantities 'sin(x)' and 'cos(x)'. FriCAS can handle such relations between elementary functions (via 'normalize'), but does not do this automatically. But elementary constants cause theoretical trouble (see SchanuelConjecture). And nonelementary functions may satisfy relations unknown to FriCAS. Similarly, 'Expression(Integer)' treats algebraic quantities as independent: \begin{axiom} a := x^(1/4) b := sqrt(x) a^2 - b -a^2 - b \end{axiom} Mathematically, for given 'x' in a field, one of the two expressions above must be zero. But FriCAS shows both as if they were nonzero. At deeper level, FriCAS treats expression as rational function of kernels. Simple calculations in 'Expression(Integer)' are correct only if kernels are independent, that is transcentental kernels are algebraically independent and defining polynomials of algebraic kernels are irreducible. For transcendental elementary functions 'normalize' from 'ElementaryFunctionStructurePackage' rewrites expression in terms of algebraically independent kernels. Note: For simpler, more specialized domains like 'DMP([a,b], Integer)',

[SymbolsAndVariables]

Mon, 12 May 2025 12:39:56 +0000

??changed: -This is confirmed by (2), where the assignment is immediate because y:Variable(y). Thus from 'Symbol' to Variable() seems to me automatic *in the interpreter* but temporarily. Temporarily, because you can reassign the identifier to any other typed value. This is different than manually declaring the identifier as y: Variable(y). You cannot reassign with y:=1 later without changing the declaration of its type. This is confirmed by (2), where the assignment is immediate because y:Variable(y). So, when we get 'Symbol', this is via two stage process. First, identifier entered by the user is turnend into Variable(). Usually. this is only temporary. Namely, "interpreter" coercion machinery can coerce Variable() to a 'Symbol'. Why this two stage process? FriCAS wants to offer symbolic computation, that is users may write symbolic expression containing mathematical variables. But programming also needs variables. From implementation point of view the two kinds of variables are quite different: mathematical variables are data of some type, programming language variables store data. But we do not want any special notation to distinguish them. Instead FriCAS uses coercion machinery to assign role to identifiers. Variable(y) really says that FriCAS up to now did not decide if this is programming language variable or a symbolic one. Of course, once Variable(y) is stored in a variable it is data. But before that, during internal processing, interpreter can treat it as a programming language variable or coerce to a symbol. A symbol is a data, typically mathematical variable, but can be used in more general way. When we manually declare the identifier as y: Variable(y), than it has this type. You cannot reassign with y:=1 later without changing the declaration of its type. ??changed: -The difference between y:Variable(y) and y:Symbol for the interpreter is thus that an undefined identifier 'y' behaves as 'Symbol' only transiently on its way to 'Variable(y)', and need to be explicitly coerced back to 'Symbol'. The difference between y:Variable(y) and y:Symbol for the interpreter is thus that an undefined identifier 'y' first is treated as 'Variable(y)', but may be coerced to 'Symbol'. And sometimes it need to be explicitly coerced to 'Symbol'. ??changed: -Now, the real confusion is when one starts using the compiler! (By the way, in Windows 0.1.4 version, all compiling of the test packages, a message appears: - -'The syntax of the command is incorrect.' - -This does not appear below. Also there is a problem with MathAction/Wiki processing a comment line such as Now, the real confusion is when one starts using the compiler! Also there is a problem with MathAction/Wiki processing a comment line such as ??changed: -So these are omitted from below.) So these are omitted from below. ++added: But running it gives an error: ++added: This error explains part of the difference: FriCAS types are parametrized and creation of actual type. that is substituting actual arguments into a type, happens at runtime. When code tries to substitute 'y' into 'Variable(y)' programming language variable 'y' has no defined value, so substitution fails. Interpreter is more forgiving, converting identifier 'y' into the corresonding symbol and passing that to 'Variable'. Other differences have similar reason: interpreter is trying very hard to coerce data to expected type, while Spad compiler needs explicit coercions. Also, note that compiler says '[1] symVar3: y has no value' which warns us that 'y' is uninitialized. But detection of uninitialized variables is not reliable, compiler may fail to see that variable is uninitialized, so this is only a warning, not an error. Writing argument to 'Variable' as '"x"::Symbol' ensures correct type in this place. But resulting type is beyond capability of Spad compiler, it does not see that 'y' can give value of type 'Variable("y"::Symbol)': \begin{spad} )abbrev package SVT3 SymbolVariableTest3a SymbolVariableTest3a(): Spec == Imp where Spec == with symVar3:() -> Boolean Imp == add symVar3()== x : Variable("y"::Symbol):=y t : Boolean:= true \end{spad} The example y :Variable(y):=y is a special case.

[ForksInfo]

Mon, 12 May 2025 10:20:28 +0000

??changed: - You can find source code, binaries files and more documentation for Tim Daly Axiom at http://www.axiom-developer.org/ - Note: Apparently recent Axiom effort is only private, the site above was not updated for several years. - You can find source code, binaries files and more documentation at https://www.nongnu.org/axiom/ (Tim Daly had a website, but it is defunt now). Note: Apparently recent Axiom effort is only private, the site above is essentially a record of older developement, with some updates to build on current systems.

[LanguageDifferences]

Thu, 03 Apr 2025 16:02:19 +0000

??changed: -Currenly in FriCAS interpreter and Spad compiler share the first stage. -Conseqently Spad and intepreter keyword are almost the same, Currently in FriCAS interpreter and Spad compiler share the first stage. Consequently Spad and interpreter keyword are almost the same, ??changed: -intepreter would make them. For exmaple:: interpreter would make them. For example:: ??changed: - Rather it is a function name in the Axiom library. Rather it is a function name in the FriCAS library. ??changed: - In Spad ``==`` means *delayed assignment*. In Spad ``==`` means *function definition* (possibly having constant value). ??changed: - * Spad uses an apostroph to introduce a symbol:: * Spad uses an apostrophe to introduce a symbol:: ??changed: - In Aldor, the apostroph is reserved, and used for the In Aldor, the apostrophe is reserved, and used for the

[ProgrammingSPAD]

Thu, 03 Apr 2025 15:52:39 +0000

??changed: -More information about SPAD can be found in the "Axiom book":http://fricas.sourceforge.net/doc . More information about SPAD can be found in the FriCAS "book":https://fricas.github.io/book.pdf . ??changed: -See also "How does one program in the AXIOM System":http://axiom-wiki.newsynthesis.org/public/refs/davenport92how.pdf . See also "How does one program in the AXIOM System":http://wiki.fricas.org/public/refs/davenport92how.pdf . ??changed: -There are, however, a number of "differences between SPAD and Aldor":http://axiom-wiki.newsynthesis.org/LanguageDifferences . There are, however, a number of "differences between SPAD and Aldor":LanguageDifferences . ??changed: -To "try out SPAD online":http://axiom-wiki.newsynthesis.org/SandBoxTryOutSPAD you simply edit a wiki Sandbox page and To "try out SPAD online":SandBoxTryOutSPAD you simply edit a wiki Sandbox page and

[Division by zero during evaluation]

Mon, 03 Feb 2025 10:38:07 +0000

??changed: -Take differential form $dx/\sqrt(x^3 - 1)$. This form have no Take differential form $dx/\sqrt{x^3 - 1}$. This form have no ??changed: -for all point: for any fixed coordinate system there will be singular for all points: for any fixed coordinate system there will be singular ++added: Algebraic expressions require care and computations may be tedious, but at least in theory we can avoid division by $0$. However, in general it is undecidable if a mathematical expression gives $0$ as a value. One approach to this difficulty is to divide only by expressions which are known to be non-zero. Applied naively this would severly limit possible computations. FriCAS uses somewhat different approach: computations are normally done in domains where we can decide if an expression is zero. However, such domain may be different from domain intended by user. For example, in most operations FriCAS treats Dirac delta "function" as transcendental quantity. This allows computations which would make no sense from point of view of analysis. But if final result is sensible (in partucular does not lead to division by Dirac delta), then it is analytically correct. Similar approach deals with branches of multivalued functions: FriCAS works with algebraic (or transcendental) extentions (fields). If element of an extention is zero, then it is zero under any analytic interpretation (any choice of branches). But specific choices of branches can lead to more equalities. Still, if final result does not lead to division by zero, then it is correct at least for some choice of branches.