Your Spad example is exactly what I was will looking for. Yes!! And looking
at the code was very easy to understand now!
In fact I would like a system command with example when they are available
à la Julia. Or something else like that, that doesn't matter. And in Spad
almost all I want is there, I didn't know. I love also the fullDisplay from
you beginning example, but more is in:
(15) -> fullDisplay str
fullDisplay str
string : (OutputForm)->String from OutputFormTools (unexposed)
string : (Integer)->% from StringCategory
string : (%)->Str from SExpressionCategory(Str,Sym,Int,Flt)
string : (%)->String from JLObjectType
string : (%)->String from JLType
string : (%)->String from JLInt64
string : (%)->String from Symbol
This is not the documentation here but I also need where the doc come from,
domains, categories, packages. In FriCAS with Julia support I have for
example:
(16) -> )jlApropos svd
)jlApropos svd
LinearAlgebra.svdvals
LinearAlgebra.svd!
LinearAlgebra.GeneralizedSVD
LinearAlgebra.svdvals!
LinearAlgebra.rank
LinearAlgebra.svd
LinearAlgebra.SVD
LinearAlgebra.LAPACK.ggsvd!
LinearAlgebra.LAPACK.gesvd!
LinearAlgebra.LAPACK.ggsvd3!
LinearAlgebra.LAPACK.gelsd!
There is also in FriCAS (the orthographic corrector is only there because I
cut and paste the interpreter output in a themed editor but colored name
are in the interpreter):
(16) -> )jlDoc svd
)jlDoc svd
svd(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD
Compute the singular value decomposition (SVD) of A and return an SVD
object.
U, S, V and Vt can be obtained from the factorization F with F.U, F.S, F.V
and F.Vt, such that A = U * Diagonal(S) * Vt. The algorithm produces Vt
and
hence Vt is more efficient to extract than V. The singular values in S are
sorted in descending order.
Iterating the decomposition produces the components U, S, and V.
If full = false (default), a "thin" SVD is returned. For an M \times N
matrix A, in the full factorization U is M \times M and V is N \times N,
while in the thin factorization U is M \times K and V is N \times K, where
K
= \min(M,N) is the number of singular values.
If alg = DivideAndConquer() a divide-and-conquer algorithm is used to
calculate the SVD. Another (typically slower but more accurate) option is
alg = QRIteration().
│ Julia 1.3
│
│ The alg keyword argument requires Julia 1.3 or later.
Examples
≡≡≡≡≡≡≡≡
julia> A = rand(4,3);
julia> F = svd(A); # Store the Factorization Object
julia> A ≈ F.U * Diagonal(F.S) * F.Vt
true
julia> U, S, V = F; # destructuring via iteration
julia> A ≈ U * Diagonal(S) * V'
true
julia> Uonly, = svd(A); # Store U only
julia> Uonly == U
true
svd(A, B) -> GeneralizedSVD
Compute the generalized SVD of A and B, returning a GeneralizedSVD
factorization object F such that [A;B] = [F.U * F.D1; F.V * F.D2] * F.R0 *
F.Q'
• U is a M-by-M orthogonal matrix,
• V is a P-by-P orthogonal matrix,
• Q is a N-by-N orthogonal matrix,
• D1 is a M-by-(K+L) diagonal matrix with 1s in the first K entries,
• D2 is a P-by-(K+L) matrix whose top right L-by-L block is
diagonal,
• R0 is a (K+L)-by-N matrix whose rightmost (K+L)-by-(K+L) block is
nonsingular upper block triangular,
K+L is the effective numerical rank of the matrix [A; B].
Iterating the decomposition produces the components U, V, Q, D1, D2, and
R0.
The generalized SVD is used in applications such as when one wants to
compare how much belongs to A vs. how much belongs to B, as in human vs
yeast genome, or signal vs noise, or between clusters vs within clusters.
(See Edelman and Wang for discussion: https://arxiv.org/abs/1901.00485)
It decomposes [A; B] into [UC; VS]H, where [UC; VS] is a natural
orthogonal
basis for the column space of [A; B], and H = RQ' is a natural
non-orthogonal basis for the rowspace of [A;B], where the top rows are
most
closely attributed to the A matrix, and the bottom to the B matrix. The
multi-cosine/sine matrices C and S provide a multi-measure of how much A
vs
how much B, and U and V provide directions in which these are measured.
Examples
≡≡≡≡≡≡≡≡
julia> A = randn(3,2); B=randn(4,2);
julia> F = svd(A, B);
julia> U,V,Q,C,S,R = F;
julia> H = R*Q';
julia> [A; B] ≈ [U*C; V*S]*H
true
julia> [A; B] ≈ [F.U*F.D1; F.V*F.D2]*F.R0*F.Q'
true
julia> Uonly, = svd(A,B);
julia> U == Uonly
true
- Greg
--
You received this message because you are subscribed to the Google Groups
"FriCAS - computer algebra system" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To view this discussion visit
https://groups.google.com/d/msgid/fricas-devel/CAHnU2dYaMnFOhHG1MxFXfb9-0QHRzR6cceTpb6F9m9aWga%3DgSg%40mail.gmail.com.
