MathAction changed pages
http://wiki.fricas.org
MathAction changed pagesenThu, 23 Nov 2023 14:12:59 +0000[SandboxErik]
http://wiki.fricas.org/SandboxErik
http://wiki.fricas.org/SandboxErik
??changed:
How can I rewrite a expression to with respect to a variable? For example v=H*r and to make axiom rewrite this as r=H/r?
How can I rewrite a expression to with respect to a variable? For example v=H*r and to make FriCAS rewrite this as r=H/r?
++added:
lcm([2, 6, 9])
Fri, 08 Dec 2023 13:56:02 +0000[FriCAS]
http://wiki.fricas.org/FriCAS
http://wiki.fricas.org/FriCAS
??changed:
(http://www.math.uni.wroc.pl/~hebisch).
(http://fricas.org/~hebisch).
??changed:
When editing pages on this wiki you can specify which
version/fork of Axiom you wish to use to execute the
commands in the !\begin{axiom} ... \end{axiom} environment.
This page is currently set to 'Axiom: friCAS20090114':
Pages on this wiki are rendered using current version of FriCAS:
++added:
After a page was rendered its content is cached and will change only
after edit or explicit request for refresh.
Tue, 05 Dec 2023 16:46:13 +0000[HyperDoc]
http://wiki.fricas.org/HyperDoc
http://wiki.fricas.org/HyperDoc
??changed:
 1) Add page to database used by HyperDoc. For this change to
 directory contaning ht.db file (this directory also contains .ht
 and .pht files)  relative to top of you installation this is

 target/platform/share/hyperdoc/pages subdirectory

 where platform is name of your platform (something like
 x86_64unknownlinux or i386pcmingw32). Next

 rm ht.db # remove the old ht.db file.
 /path/to/your/fricas/installation/target/platform/bin/htadd *.ht

 Note: htadd program only add things to database. So, to avoid
 keeping old entries (which may be wrong if you change a page)
 we remove database first.

 2) Generate the .pht file (this file contains output from examples).

 To do this use command like:
[18 more lines...]
1 Add page to database used by HyperDoc. For this change to
directory contaning ht.db file (this directory also contains .ht
and .pht files)  relative to top of you installation this is:
target/platform/share/hyperdoc/pages subdirectory
where platform is name of your platform (something like
x86_64unknownlinux or i386pcmingw32). Next:
rm ht.db # remove the old ht.db file.
/path/to/your/fricas/installation/target/platform/bin/htadd *.ht
Note: htadd program only add things to database. So, to avoid
keeping old entries (which may be wrong if you change a page)
we remove database first.
2 Generate the .pht file (this file contains output from examples).
To do this use command like:
export FRICAS=/path/to/your/fricas/installation/target/platform;
$FRICAS/bin/sman noihere paste file.ht
3 Regenerate database adding freshly produced .pht file:
rm ht.db # remove the old ht.db file.
/path/to/your/fricas/installation/target/platform/bin/htadd *.ht *.pht
Note1: in the first step it is better to add only .ht pages to database.
In the third step we add both .ht and .pht files (otherwise the examples
would be missing).
Note2: the second step also produces .input file. This file may be
safely deleted.
Tue, 05 Dec 2023 16:45:09 +0000[AldorForFriCAS]
http://wiki.fricas.org/AldorForFriCAS
http://wiki.fricas.org/AldorForFriCAS
??changed:
option is needed to avoid failures due to mismatche autotools versions.
option is needed to avoid failures due to mismatched autotools versions.
Tue, 05 Dec 2023 16:03:00 +0000[PanAxiomCommunity]
http://wiki.fricas.org/PanAxiomCommunity
http://wiki.fricas.org/PanAxiomCommunity
removed:
"axiomcommit":https://lists.sourceforge.net/lists/listinfo/axiomcommit ("archive":http://sourceforge.net/mailarchive/forum.php?forum=axiomcommit)  tracks all commits to the SourceForge SVN repository
(dubbed "silver branch")

"axiomtestresults":https://lists.sourceforge.net/lists/listinfo/axiomtestresults ("archive":http://sourceforge.net/mailarchive/forum.php?forum=axiomtestresults)  everything having to do with the results of building and testing
Axiom

"aldorl":http://www.aldor.org/mailman/listinfo/aldorl ("archive":http://www.aldor.org/pipermail/aldorl) 
 public mailing list used by aldor users


Tue, 05 Dec 2023 15:59:33 +0000[PanAxiom]
http://wiki.fricas.org/PanAxiom
http://wiki.fricas.org/PanAxiom
??changed:
OpenAxiom developement stopped in 2015.
OpenAxiom developement stopped in 2015 and Tim Daly did no release
in last several years. So FriCAS is the only "live" fork, that
is the only fork with visible active development.
Tue, 05 Dec 2023 15:56:43 +0000[Symbolic Integration]
http://wiki.fricas.org/SymbolicIntegration
http://wiki.fricas.org/SymbolicIntegration
??changed:
RischBronsteinTrager algorithm (Risch algorithm in short) is a complete algorithom
RischBronsteinTrager algorithm (Risch algorithm in short) is a complete algorithm
??changed:
"most complete" existing implementation. Unfortunatly "most complete" does
"most complete" existing implementation. Unfortunately "most complete" does
??changed:
almost surely there is on elementary integral. Almost surely, because
almost surely there is no elementary integral. Almost surely, because
??changed:
fresnelS, fresnelC, incomplete Gamma and
polylog. There is complete extended algorithm for large class of functions
(but 'polylog' causes tricky theoretical problems). Compared to
fresnelS, fresnelC, incomplete Gamma, polylogs and elliptic integrals. There is complete
extended algorithm for large class of functions. However 'polylog' and elliptic integrals cause
tricky theoretical problems. Compared to
??changed:
Additionaly to Risch integrator FriCAS contains relativly weak pattern matching
integrator which can generate a few special functions  Ei, li, dilog
and erf. However, if integral really requires
elliptic functions then the best thing which FriCAS can do is to prove that integral
is nonelementary.
FriCAS used to contain relatively weak pattern matching integrator capable of generating a few special functions  Ei, li, dilog
and erf. Currently pattern matching is only used for one case of definite integration, all indefinite
integrals are done by Risch algorithm or extentions and shortcuts.
??changed:
In this case FriCAS neither can compute elementry result nor can it prove that result is not elementary,
is it gives up with error message indicating that the handling this integral requires unimplemented
In this case FriCAS neither can compute elementary result nor can it prove that result is not elementary,
so it gives up with error message indicating that the handling this integral requires unimplemented
??changed:
 This time FriCAS can prove that result is nonelementary (it needs elliptic functions).
This time FriCAS can prove that result is nonelementary and returns answer in terms of elliptic functions.
Tue, 05 Dec 2023 15:54:10 +0000[FrontPage]
http://wiki.fricas.org/FrontPage
http://wiki.fricas.org/FrontPage
??changed:
 <li>"Papers":http://fricaswiki.math.uni.wroc.pl/public/refs/articles.html</li>
<li>"Papers":http://wiki.fricas.org/public/refs/articles.html</li>
??changed:
 <li><small>"old online version":http://fricaswiki.math.uni.wroc.pl/uploads/contents.xhtml</small></li></ul>
<li><small>"old online version":http://wiki.fricas.org/uploads/contents.xhtml</small></li></ul>
Thu, 23 Nov 2023 14:37:00 +0000[FriCASProgramming]
http://wiki.fricas.org/FriCASProgramming
http://wiki.fricas.org/FriCASProgramming
??changed:
crash course see ProgrammingSPAD.
crash course see ProgrammingSPAD. For higher level overview see FriCASProgrammingModel.
Thu, 09 Nov 2023 16:00:40 +0000[FriCASProgrammingModel]
http://wiki.fricas.org/FriCASProgrammingModel
http://wiki.fricas.org/FriCASProgrammingModel
??changed:

FriCAS language (both interpreter and Spad) is imperative, basic operation is an assignment like
\begin{axiom}
a : Integer := 5
b : Integer := a + 2
\end{axiom}
FriCAS language is typed, each variable and expression have type, assigned value must have
correct type. Above we explicitly declared 'a' and 'b' to be of type 'Integer'. In same cases FriCAS can
infer the correct type and allows use of variables without explicit declaration. Interpreter
tries to assign reasonable type guessing user intent. Remark: this is quite different than type
inference present in same languages.
Next element of FriCAS language are expression. In first approximation expressions can be viewed
as tree of function calls with variables in the leaves. Remark: FriCAS treats various operators like functions. So '*' is a two
argument function. The difference compared to ordinary functions is syntax, '*' is parsed as infix
operator, but after parsing is indistingiushable from a function. So 'a+b*c' is eqivalent to
'f(a, g(b,c))' where 'f' denotes addition ('+') and 'g' denotes multiplication ('*'). Actually,
FriCAS expressions are more complicated, one can use almost any part of FriCAS syntax inside an
expression, but simple tree view is enough for basic understanding.
FriCAS supports overloading, that is one can give different definition of a function for various
combinations of parameter types. For example, with declarations above 'a*b' is multiplication
of integers. However, if 'c' is vector of integer, than 'a*c' means multiplication of vector
'c' by integer 'a' which is a different operation despite having the same name. Remark: FriCAS
treats various operators like functions. So '*' is a two argument function. The difference
compared to ordinary functions is syntax, '*' is parsed as infix operator, but after parsing
is indistinguishable from a function.
FriCAS types are parametric, for example 'Polynomial(Integer)' is application of constructor
'Polynomial' to parameter 'Integer'. 'Polynomial(Fraction(Integer))' is a different type
obtained using the same constructor, but with different parameter, that is 'Fraction(Integer)',
which is application of constructor 'Fraction' to type 'Integer'. Parameter usually are
types, but it is also possible to use normal values as parameters.
Parametric types lead to parametric polymorphizm. This is similar to overloading, but conceptually
and in implementation there is a difference. For example, writing 'a + b' with integer 'a' and 'b'
we use '+' declared in AbelianSemigroup. When adding two polynomials we use the same declaration,
but implementation is different. Choosing correct implementation is due to dispatch, from
compiler point of view we have single operation, but at runtime support routines are responsible
for calling correct version. Of course, users may worry that function calls in FriCAS need to
do complicated things to find correct function and are expensive. However, FriCAS contains
caching mechanism, first call may be quite expensive but usually subsequent executions of the
same call have only very small overhead. Beside parametric polymorphizm there is also
classical overloading. For example multiplication of vector by integer uses different
declaration than multiplication of integers and FriCAS compiler choose proper declaration
at compile time.
FriCAS has usual imperative constructs: sequence of operations, conditionals and loops.
FriCAS allows also FunctionalProgramming: FriCAS functions are "first class", one can
pass functions as arguments to other functions, store them in variables and data structures.
One can define local functions with capture references to variables in surrounding environment.
There are usual functional utilities like 'map'.
FriCAS types are "first class": parametric types allow creating potentially infinite number of
new types at runtime, types can be stored in variables and data structures. Types can be
passed to functions as arguments.
FriCAS is strongly typed in sense that all variables and expressions have assigned type, function
call is allowed only when arguments are of apropriate types. Strict type disciples sometimes
does on allow to express desired and correct code. FriCAS allows holes in type checking,
maininly via 'pretend' construct. For example
\begin{axiom}
a pretend PositiveInteger
\end{axiom}
tells FriCAS that 'a' which is declared as 'Integer' should be treated as 'PositiveInteger'
in expression above. Use of 'pretend' should be limited to cases when user knows that
value is actually of appropriate type, but FriCAS can not infer this in authomatic way.
Improper use of 'pretend' is an error which may lead to wrong value or a crash.
Basic FriCAS types are implemented at lower level, currently in Lisp. To allow such implementation
FriCAS allows direct calls to Lisp functions. Such calls are not type checked: FriCAS assumes
on faith that argument have correct Lisp type and result is of correct FriCAS type. Note:
FriCAS uses Lisp type declarations. Passing FriCAS value to Lisp function must respect
declarations passed to Lisp. If user call to Lisp function cause type mismatch at Lisp
level this may lead to trouble. In best case Lisp will report mismatch, but wrong result
or a crash are also possible. Typical use of Lisp calls is via Spad wrapper: wrapper
ensures that only correct types are passed to Lisp function and ensures correct FriCAS
type for result.
Thu, 09 Nov 2023 16:00:08 +0000