--- Begin Message ---
Package: src:octave-symbolic
Version: 3.2.1-2
Severity: serious
Tags: ftbfs
Dear maintainer:
During a rebuild of all packages in unstable, your package failed to build:
--------------------------------------------------------------------------------
[...]
debian/rules binary
dh binary --buildsystem=octave
dh_update_autotools_config -O--buildsystem=octave
dh_autoreconf -O--buildsystem=octave
dh_octave_version -O--buildsystem=octave
Checking the Octave version... ok
dh_auto_configure -O--buildsystem=octave
dh_auto_build -O--buildsystem=octave
dh_auto_test -O--buildsystem=octave
create-stamp debian/debhelper-build-stamp
dh_testroot -O--buildsystem=octave
dh_prep -O--buildsystem=octave
dh_auto_install --destdir=debian/octave-symbolic/ -O--buildsystem=octave
octave --no-gui --no-history --silent --no-init-file --no-window-system
/usr/share/dh-octave/install-pkg.m
/<<PKGBUILDDIR>>/debian/octave-symbolic/usr/share/octave/packages
/<<PKGBUILDDIR>>/debian/octave-symbolic/usr/lib/x86_64-linux-gnu/octave/packages
[... snipped ...]
assert (isequal (potential(f, x, 0), F))
assert (isequal (potential(f, x, 2), F - 8))
***** test
F = x*exp(y) + (z-1)^2;
f = gradient(F);
G = potential(f, [x;y;z], [0;1;1]);
assert (isAlways (G == F))
***** test
F = x*exp(y);
f = gradient(F);
G = potential(f);
assert (isAlways (G == F))
***** test
% no potential exists
syms x y
a = [x; x*y^2];
assert (isnan (potential (a)))
***** shared
***** xtest
% fails b/c of sympy #8458 (piecewise expr that should simplify)
syms x
f = cos(x);
assert (isequal (potential(f, x), sin(x)))
!!!!! known failure
assert (isequal (potential (f, x), sin (x))) failed
6 tests, 5 passed, 1 known failure, 0 skipped
[inst/@sym/laplace.m]
/<<PKGBUILDDIR>>/inst/@sym/laplace.m
***** test
% basic
syms t s u w
assert(logical( laplace(cos(3*t)) == s/(s^2+9) ))
assert(logical( laplace(t^3) == 6/s^4 ))
***** test
% matlab SMT compat
syms t s u w z
assert(logical( laplace(exp(2*t)) == 1/(s-2) ))
assert(logical( laplace(exp(2*s)) == 1/(z-2) ))
assert(logical( laplace(exp(2*u),w) == 1/(w-2) ))
assert(logical( laplace(exp(2*u),u,w) == 1/(w-2) ))
***** test
syms x s t z
% matlab SMT prefers t over x
assert (isequal (laplace (x*exp (t), z), x/(z - 1)))
% as usual, you can just specify:
assert (isequal (laplace(x*exp(t), t, z), x/(z - 1))) % SMT result
assert (isequal (laplace(x*exp(t), x, z), exp(t)/z^2))
***** test
syms x a s
% if no t, use symvar: take x before a
assert (isequal (laplace (a*exp (x)), a/(s - 1)))
***** error <more than one> laplace (sym('t')*sym('t', 'real'))
***** test
% constant, issue #250
syms s
f = laplace(2, s);
assert (isequal (f, 2/s))
***** test
% Dirac delta and Heaviside tests
syms t s
assert (isequal (laplace(dirac(t-3)), exp(-3*s)))
assert (isequal (laplace((t-3)*heaviside(t-3)), exp(-3*s)/s^2))
***** xtest
% Differential operator to algebraic
% SymPy cannot evaluate? (Issue #170)
syms s f(t)
assert(logical( laplace(diff(f(t),t),t,s) == s*laplace(f(t),t,s)-f(0) ))
***** test
% https://github.com/gnu-octave/symbolic/issues/1295
% fails on SymPy 1.10.* and 1.11.*
if (pycall_sympy__ ('return Version(spver) >= Version("1.12")'))
syms t s
L = simplify (laplace (3*t*sin (4*t)));
assert (isAlways (L == 24*s / (s^2 + 16)^2))
end
9 tests, 9 passed, 0 known failure, 0 skipped
[inst/laguerreL.m]
/<<PKGBUILDDIR>>/inst/laguerreL.m
***** error laguerreL (1)
***** error laguerreL (1, 2, 3)
***** assert (isequal (laguerreL (0, rand), 1))
***** test
x = rand;
assert (isequal (laguerreL (1, x), 1 - x))
***** test
x=rand;
y1=laguerreL(2, x);
p2=[.5 -2 1];
y2=polyval(p2,x);
assert(y1 - y2, 0, 10*eps);
***** test
x=rand;
y1=laguerreL(3, x);
p3=[-1/6 9/6 -18/6 1];
y2=polyval(p3,x);
assert(y1 - y2, 0, 20*eps);
***** test
x=rand;
y1=laguerreL(4, x);
p4=[1/24 -16/24 72/24 -96/24 1];
y2=polyval(p4,x);
assert(y1 - y2, 0, 30*eps)
***** error <positive integer> laguerreL(1.5, 10)
***** error <same size or scalar> laguerreL([0 1], [1 2 3])
***** error <same size or scalar> laguerreL([0 1], [1; 2])
***** test
% numerically stable implementation (in n)
L = laguerreL (10, 10);
Lex = 1763/63;
assert (L, Lex, -eps)
L = laguerreL (20, 10);
Lex = -177616901779/14849255421; % e.g., laguerreL(sym(20),10)
assert (L, Lex, -eps)
***** test
% vectorized x
L = laguerreL (2, [5 6 7]);
Lex = [3.5 7 11.5];
assert (L, Lex, eps)
***** test
L = laguerreL (0, [4 5]);
assert (L, [1 1], eps)
***** test
% vector n
L = laguerreL ([0 1 2 3], [4 5 6 9]);
assert (L, [1 -4 7 -26], eps)
***** test
% vector n, scalar x
L = laguerreL ([0 1 2 3], 6);
assert (L, [1 -5 7 1], eps)
***** assert (isa (laguerreL (0, single (1)), 'single'))
***** assert (isa (laguerreL (1, single ([1 2])), 'single'))
***** assert (isa (laguerreL ([1 2], single ([1 2])), 'single'))
18 tests, 18 passed, 0 known failure, 0 skipped
[inst/dirac.m]
/<<PKGBUILDDIR>>/inst/dirac.m
***** assert (isinf (dirac (0)))
***** assert (dirac (1) == 0)
***** assert (isnan (dirac (nan)))
***** assert (isequaln (dirac ([-1 1 0 eps inf -inf nan]), [0 0 inf 0 0 0 nan]))
***** error <complex values> dirac (1i)
***** assert (isa (dirac (single (0)), 'single'))
6 tests, 6 passed, 0 known failure, 0 skipped
[inst/fibonacci.m]
/<<PKGBUILDDIR>>/inst/fibonacci.m
***** assert (isequal ( fibonacci (sym(0)), 0))
***** assert (isequal ( fibonacci (sym(14)), sym(377)))
***** assert (isequal ( fibonacci (14), 377))
***** test syms x
assert (isequal (fibonacci (5,x), x^4 + 3*x^2 + 1))
4 tests, 4 passed, 0 known failure, 0 skipped
[inst/lambertw.m]
/<<PKGBUILDDIR>>/inst/lambertw.m
***** assert (isequal (lambertw (0), 0))
***** assert (isequal (lambertw (0, 0), 0))
***** assert (lambertw (-1/exp(1)), -1, 2*eps)
***** assert (lambertw (0, -1/exp(1)), -1, 2*eps)
***** assert (lambertw (-1, -1/exp(1)), -1, 2*eps)
***** test
x = [1 2 3 pi 10 100 1000 12345];
W = lambertw (x);
assert (W.*exp (W), x, -3*eps)
***** test
x = [1 2 3 pi 10 100 1000 12345];
k = [-3 -2 -1 0 1 2 3 4];
W = lambertw (k, x);
assert (W.*exp (W), x, -10*eps)
***** test
% input shape preserved
x = [0 1; 2 3];
b = x;
W = lambertw (b, x);
assert (W.*exp (W), x, -10*eps)
***** test
% input shape preserved
x = [0 1; 2 3];
b = 0;
W = lambertw (b, x);
assert (W.*exp (W), x, -10*eps)
***** test
% input shape preserved
x = 10;
b = [0 1; 2 3];
W = lambertw (b, x);
assert (W.*exp (W), x*ones (size (b)), -10*eps)
***** assert (isnan (lambertw (nan)))
***** test
% limiting behaviour as z large
k = 3;
A = lambertw (k, 1e100);
assert (abs (imag (A) - 2*pi*k) < 0.1)
***** test
% limiting behaviour as z large, up imag axis
k = 1;
A = lambertw (k, 1e100*1i);
assert (abs (imag (A) - (2*k+0.5)*pi) < 0.1)
***** test
% limiting behaviour as z large, down imag axis
k = -2;
A = lambertw (k, -1e100*1i);
assert (abs (imag (A) - (2*k-0.5)*pi) < 0.1)
***** test
% limiting behaviour as z large, near branch
k = 3;
A = lambertw (k, -1e100);
B = lambertw (k, -1e100 + 1i);
C = lambertw (k, -1e100 - 1i);
assert (abs (imag (A) - (2*k+1)*pi) < 0.1)
assert (abs (imag (B) - (2*k+1)*pi) < 0.1)
assert (abs (imag (C) - (2*k-1)*pi) < 0.1)
***** test
% infinities and nan
A = lambertw ([inf exp(1) -inf nan]);
B = [inf 1 inf + pi*1i nan];
assert (isequaln (A, B))
***** test
% infinities and nan
A = lambertw (3, [inf 1 -inf nan]);
B = [inf + 2*3*pi*1i lambertw(3,1) inf + (2*3+1)*pi*1i nan];
assert (isequaln (A, B))
***** test
% infinities and nan
A = lambertw ([0 1 2 0], [inf -inf nan exp(1)]);
B = [inf inf+3*pi*1i nan 1];
assert (isequaln (A, B))
***** test
% scalar infinity z, vector b
A = lambertw ([1 2 -3], inf);
B = [lambertw(1, inf) lambertw(2, inf) lambertw(-3, inf)];
assert (isequal (A, B))
***** test
% scalar -infinity z, vector b
A = lambertw ([1 2 -3], -inf);
B = [lambertw(1, -inf) lambertw(2, -inf) lambertw(-3, -inf)];
assert (isequal (A, B))
***** test
% scalar z nan, vector b
A = lambertw ([1 2 -3], nan);
B = [nan nan nan];
assert (isequaln (A, B))
21 tests, 21 passed, 0 known failure, 0 skipped
[inst/finiteset.m]
/<<PKGBUILDDIR>>/inst/finiteset.m
***** test
s1 = finiteset(sym(1), 2, 2);
s2 = finiteset(sym(1), 2, 2, 2);
assert (isequal (s1, s2))
***** test
s1 = finiteset(sym(0), 1);
s2 = finiteset(sym(0), 2, 3);
s = finiteset(sym(0), 1, 2, 3);
assert (isequal (s1 + s2, s))
***** test
e = finiteset();
s = finiteset(sym(1));
s2 = e + s;
assert (isequal (s, s2))
3 tests, 3 passed, 0 known failure, 0 skipped
[inst/findsymbols.m]
/<<PKGBUILDDIR>>/inst/findsymbols.m
***** test
syms x b y n a arlo
z = a*x + b*pi*sin (n) + exp (y) + exp (sym (1)) + arlo;
s = findsymbols (z);
assert (isequal ([s{:}], [a,arlo,b,n,x,y]))
***** test
syms x
s = findsymbols (x);
assert (isequal (s{1}, x))
***** test
syms z x y a
s = findsymbols ([x y; 1 a]);
assert (isequal ([s{:}], [a x y]))
***** assert (isempty (findsymbols (sym (1))))
***** assert (isempty (findsymbols (sym ([1 2]))))
***** assert (isempty (findsymbols (sym (nan))))
***** assert (isempty (findsymbols (sym (inf))))
***** assert (isempty (findsymbols (exp (sym (2)))))
***** test
% empty sym for findsymbols, findsym, and symvar
assert (isempty (findsymbols (sym([]))))
assert (isempty (findsym (sym([]))))
assert (isempty (symvar (sym([]))))
***** test
% diff. assumptions make diff. symbols
x1 = sym('x');
x2 = sym('x', 'positive');
f = x1*x2;
assert (length (findsymbols (f)) == 2)
***** test
% symfun or sym
syms x f(y)
a = f*x;
b = f(y)*x;
assert (isequal (findsymbols(a), {x y}))
assert (isequal (findsymbols(b), {x y}))
***** test
% findsymbols on symfun does not find the argnames (unless they
% are on the RHS of course, this matches SMT 2014a).
syms a x y
f(x, y) = a; % const symfun
assert (isequal (findsymbols(f), {a}))
syms a x y
f(x, y) = a*y;
assert (isequal (findsymbols(f), {a y}))
***** test
% sorts lexicographically, same as symvar *with single input*
% (note symvar does something different with 2 inputs).
syms A B a b x y X Y
f = A*a*B*b*y*X*Y*x;
assert (isequal (findsymbols(f), {A B X Y a b x y}))
assert (isequal (symvar(f), [A B X Y a b x y]))
***** test
% symbols in matpow
syms x y
syms n
A = [sin(x) 2; y 1];
B = A^n;
L = findsymbols(B);
assert (isequal (L, {n x y}))
***** test
% array of eq
syms x y
assert (isequal (findsymbols (2 == [2 x y]), {x y}))
***** test
% array of ineq
syms x y
A = [x < 1 2*x < y x >= 2 3 <= x x != y];
assert (isequal (findsymbols (A), {x y}))
16 tests, 16 passed, 0 known failure, 0 skipped
[inst/assume.m]
/<<PKGBUILDDIR>>/inst/assume.m
***** error <if you want output>
a = assume('a', 'real')
***** error <cannot have only assumptions>
assume positive integer
***** error <no assumptions>
assume x y
***** error <should be the final>
assume x clear real
***** error <algebraic assumptions are not supported>
assume a>0
***** error <only symbols>
assume 'x/pi' integer
***** test
syms x
assume x positive
a = assumptions(x);
assert(strcmp(a, 'x: positive'))
assume x even
a = assumptions(x);
assert(strcmp(a, 'x: even'))
***** test
% multiple assumptions
syms x
assume x positive integer
[tilde, a] = assumptions(x, 'dict');
assert(a{1}.integer)
assert(a{1}.positive)
***** test
% does workspace
syms x positive
x2 = x;
f = sin(x);
assume x negative
a = assumptions(x);
assert(strcmp(a, 'x: negative'))
a = assumptions(x2);
assert(strcmp(a, 'x: negative'))
a = assumptions(f);
assert(strcmp(a, 'x: negative'))
***** error <undefined>
% does not create new variable x
clear x
assume x real
***** error <undefined>
% no explicit variable named x
clear x
f = 2*sym('x');
assume x real
***** test
% clear does workspace
syms x positive
f = 2*x;
assume x clear
assert (isempty (assumptions (f)));
assert (isempty (assumptions ()));
***** test
syms x y
f = sin (2*x);
assume x y real
assert (strcmp (assumptions (x), 'x: real'))
assert (strcmp (assumptions (y), 'y: real'))
assert (strcmp (assumptions (f), 'x: real'))
***** test
syms x y
f = sin (2*x);
assume x y positive even
assert (strcmp (assumptions (x), 'x: positive, even') || strcmp (assumptions
(x), 'x: even, positive'))
assert (strcmp (assumptions (y), 'y: positive, even') || strcmp (assumptions
(y), 'y: even, positive'))
assert (strcmp (assumptions (f), 'x: positive, even') || strcmp (assumptions
(f), 'x: even, positive'))
***** test
% works from variable names not symbols
syms x y
a = [x y];
assume a real
assert (strcmp (assumptions (x), 'x: real'))
assert (strcmp (assumptions (y), 'y: real'))
***** test
% works from variable names not symbols
y = sym('x');
f = 2*y;
assume y real
assert (strcmp (assumptions (f), 'x: real'))
***** test
% matrix of symbols
syms a b c d
A = [a b; c d];
assume A real
assert (strcmp (assumptions (a), 'a: real'))
assert (strcmp (assumptions (b), 'b: real'))
assert (strcmp (assumptions (c), 'c: real'))
assert (strcmp (assumptions (d), 'd: real'))
***** test
% assume after symfun
clear x
syms f(x)
assume x real
assert (~ isempty (assumptions (formula (f))))
assert (~ isempty (assumptions (argnames (f))))
18 tests, 18 passed, 0 known failure, 0 skipped
[inst/digits.m]
/<<PKGBUILDDIR>>/inst/digits.m
***** test
orig = digits(32); % to reset later
m = digits(64);
p = vpa(sym(pi));
assert (abs (double (sin(p))) < 1e-64)
n = digits(m);
assert (n == 64)
p = vpa(sym(pi));
assert (abs (double (sin(p))) < 1e-32)
assert (abs (double (sin(p))) > 1e-40)
digits(orig)
1 test, 1 passed, 0 known failure, 0 skipped
[inst/poly2sym.m]
/<<PKGBUILDDIR>>/inst/poly2sym.m
***** shared x,y,a,b,c,p
syms x y a b c
p = x^3 + 2*x^2 + 3*x + 4;
***** assert(isAlways( poly2sym([1 2 3 4]) == p ))
***** assert(isAlways( poly2sym([1 2 3 4],x) == p ))
***** assert(isAlways( poly2sym([1 2 3 4],y) == subs(p,x,y) ))
***** assert(isAlways( poly2sym([1 2 3 4],5) == subs(p,x,5) ))
***** assert(isequal( poly2sym ([1]), 1 ))
***** assert(isequal( poly2sym ([]), 0 ))
***** assert(isAlways( poly2sym(sym([1 2 3 4]),x) == p ))
***** assert(isAlways( poly2sym([a b c],x) == a*x^2 + b*x + c ))
***** assert(isAlways( poly2sym([a b c]) == a*x^2 + b*x + c ))
***** assert(isequal( poly2sym(sym([])), 0 ))
***** assert(isAlways( poly2sym({sym(1) sym(2)}, x) == x + 2 ))
***** assert(isequal( poly2sym ({1}), 1 ))
***** assert(isequal( poly2sym ({}), 0 ))
***** assert(isequal( poly2sym ({1}, x), 1 ))
***** assert(isequal( poly2sym ({}, x), 0 ))
***** assert(isAlways( poly2sym([x x], x) == x^2 + x ))
***** test
% mixed cell array with doubles and syms
assert (isequal (poly2sym ({2.0 sym(3) int64(4)}), 2*x^2 + 3*x + 4))
***** test
% string for x
p = poly2sym ([1 2], 's');
syms s
assert (isequal (p, s + 2))
18 tests, 18 passed, 0 known failure, 0 skipped
Checking C++ files ...
Done running the unit tests.
Summary: 2426 tests, 2394 passed, 31 known failures, 0 skipped
Some tests failed. Giving up...
make: *** [debian/rules:5: binary] Error 1
dpkg-buildpackage: error: debian/rules binary subprocess returned exit status 2
--------------------------------------------------------------------------------
The above is just how the build ends and not necessarily the most relevant part.
If required, the full build log is available here:
https://people.debian.org/~sanvila/build-logs/202410/
About the archive rebuild: The build was made on virtual machines from AWS,
using sbuild and a reduced chroot with only build-essential packages.
If you could not reproduce the bug please contact me privately, as I
am willing to provide ssh access to a virtual machine where the bug is
fully reproducible.
If this is really a bug in one of the build-depends, please use
reassign and affects, so that this is still visible in the BTS web
page for this package.
Thanks.
--- End Message ---
pgp5YcDlIShdy.pgp
