Diff of the two buildlogs: -- --- b1/build.log 2024-11-11 18:35:59.226429507 +0000 +++ b2/build.log 2024-11-11 18:59:08.412952304 +0000 @@ -1,6 +1,6 @@ I: pbuilder: network access will be disabled during build -I: Current time: Sun Dec 14 12:50:49 -12 2025 -I: pbuilder-time-stamp: 1765759849 +I: Current time: Tue Nov 12 08:36:02 +14 2024 +I: pbuilder-time-stamp: 1731350162 I: Building the build Environment I: extracting base tarball [/var/cache/pbuilder/unstable-reproducible-base.tgz] I: copying local configuration @@ -30,54 +30,86 @@ dpkg-source: info: applying fix-intersect-unit-test.patch I: Not using root during the build. I: Installing the build-deps -I: user script /srv/workspace/pbuilder/17719/tmp/hooks/D02_print_environment starting +I: user script /srv/workspace/pbuilder/58132/tmp/hooks/D01_modify_environment starting +debug: Running on ionos2-i386. +I: Changing host+domainname to test build reproducibility +I: Adding a custom variable just for the fun of it... +I: Changing /bin/sh to bash +'/bin/sh' -> '/bin/bash' +lrwxrwxrwx 1 root root 9 Nov 11 18:36 /bin/sh -> /bin/bash +I: Setting pbuilder2's login shell to /bin/bash +I: Setting pbuilder2's GECOS to second user,second room,second work-phone,second home-phone,second other +I: user script /srv/workspace/pbuilder/58132/tmp/hooks/D01_modify_environment finished +I: user script /srv/workspace/pbuilder/58132/tmp/hooks/D02_print_environment starting I: set - BUILDDIR='/build/reproducible-path' - BUILDUSERGECOS='first user,first room,first work-phone,first home-phone,first other' - BUILDUSERNAME='pbuilder1' - BUILD_ARCH='i386' - DEBIAN_FRONTEND='noninteractive' - DEB_BUILD_OPTIONS='buildinfo=+all reproducible=+all parallel=22 ' - DISTRIBUTION='unstable' - HOME='/root' - HOST_ARCH='i386' + BASH=/bin/sh + BASHOPTS=checkwinsize:cmdhist:complete_fullquote:extquote:force_fignore:globasciiranges:globskipdots:hostcomplete:interactive_comments:patsub_replacement:progcomp:promptvars:sourcepath + BASH_ALIASES=() + BASH_ARGC=() + BASH_ARGV=() + BASH_CMDS=() + BASH_LINENO=([0]="12" [1]="0") + BASH_LOADABLES_PATH=/usr/local/lib/bash:/usr/lib/bash:/opt/local/lib/bash:/usr/pkg/lib/bash:/opt/pkg/lib/bash:. + BASH_SOURCE=([0]="/tmp/hooks/D02_print_environment" [1]="/tmp/hooks/D02_print_environment") + BASH_VERSINFO=([0]="5" [1]="2" [2]="32" [3]="1" [4]="release" [5]="i686-pc-linux-gnu") + BASH_VERSION='5.2.32(1)-release' + BUILDDIR=/build/reproducible-path + BUILDUSERGECOS='second user,second room,second work-phone,second home-phone,second other' + BUILDUSERNAME=pbuilder2 + BUILD_ARCH=i386 + DEBIAN_FRONTEND=noninteractive + DEB_BUILD_OPTIONS='buildinfo=+all reproducible=+all parallel=10 ' + DIRSTACK=() + DISTRIBUTION=unstable + EUID=0 + FUNCNAME=([0]="Echo" [1]="main") + GROUPS=() + HOME=/root + HOSTNAME=i-capture-the-hostname + HOSTTYPE=i686 + HOST_ARCH=i386 IFS=' ' - INVOCATION_ID='07a79186a1f54ba6959030292c10b2e4' - LANG='C' - LANGUAGE='en_US:en' - LC_ALL='C' - LD_LIBRARY_PATH='/usr/lib/libeatmydata' - LD_PRELOAD='libeatmydata.so' - MAIL='/var/mail/root' - OPTIND='1' - PATH='/usr/sbin:/usr/bin:/sbin:/bin:/usr/games' - PBCURRENTCOMMANDLINEOPERATION='build' - PBUILDER_OPERATION='build' - PBUILDER_PKGDATADIR='/usr/share/pbuilder' - PBUILDER_PKGLIBDIR='/usr/lib/pbuilder' - PBUILDER_SYSCONFDIR='/etc' - PPID='17719' - PS1='# ' - PS2='> ' + INVOCATION_ID=c9a174d3815847cdb0c11f806ccc42f7 + LANG=C + LANGUAGE=de_CH:de + LC_ALL=C + LD_LIBRARY_PATH=/usr/lib/libeatmydata + LD_PRELOAD=libeatmydata.so + MACHTYPE=i686-pc-linux-gnu + MAIL=/var/mail/root + OPTERR=1 + OPTIND=1 + OSTYPE=linux-gnu + PATH=/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path + PBCURRENTCOMMANDLINEOPERATION=build + PBUILDER_OPERATION=build + PBUILDER_PKGDATADIR=/usr/share/pbuilder + PBUILDER_PKGLIBDIR=/usr/lib/pbuilder + PBUILDER_SYSCONFDIR=/etc + PIPESTATUS=([0]="0") + POSIXLY_CORRECT=y + PPID=58132 PS4='+ ' - PWD='/' - SHELL='/bin/bash' - SHLVL='2' - SUDO_COMMAND='/usr/bin/timeout -k 18.1h 18h /usr/bin/ionice -c 3 /usr/bin/nice /usr/sbin/pbuilder --build --configfile /srv/reproducible-results/rbuild-debian/r-b-build.UvrI7bPY/pbuilderrc_hDET --distribution unstable --hookdir /etc/pbuilder/first-build-hooks --debbuildopts -b --basetgz /var/cache/pbuilder/unstable-reproducible-base.tgz --buildresult /srv/reproducible-results/rbuild-debian/r-b-build.UvrI7bPY/b1 --logfile b1/build.log octave-symbolic_3.2.1-3.dsc' - SUDO_GID='112' - SUDO_UID='107' - SUDO_USER='jenkins' - TERM='unknown' - TZ='/usr/share/zoneinfo/Etc/GMT+12' - USER='root' - _='/usr/bin/systemd-run' - http_proxy='http://213.165.73.152:3128' + PWD=/ + SHELL=/bin/bash + SHELLOPTS=braceexpand:errexit:hashall:interactive-comments:posix + SHLVL=3 + SUDO_COMMAND='/usr/bin/timeout -k 24.1h 24h /usr/bin/ionice -c 3 /usr/bin/nice -n 11 /usr/bin/unshare --uts -- /usr/sbin/pbuilder --build --configfile /srv/reproducible-results/rbuild-debian/r-b-build.UvrI7bPY/pbuilderrc_c78u --distribution unstable --hookdir /etc/pbuilder/rebuild-hooks --debbuildopts -b --basetgz /var/cache/pbuilder/unstable-reproducible-base.tgz --buildresult /srv/reproducible-results/rbuild-debian/r-b-build.UvrI7bPY/b2 --logfile b2/build.log octave-symbolic_3.2.1-3.dsc' + SUDO_GID=112 + SUDO_UID=107 + SUDO_USER=jenkins + TERM=unknown + TZ=/usr/share/zoneinfo/Etc/GMT-14 + UID=0 + USER=root + _='I: set' + http_proxy=http://46.16.76.132:3128 I: uname -a - Linux ionos6-i386 6.1.0-27-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.115-1 (2024-11-01) x86_64 GNU/Linux + Linux i-capture-the-hostname 6.1.0-27-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.115-1 (2024-11-01) x86_64 GNU/Linux I: ls -l /bin - lrwxrwxrwx 1 root root 7 Aug 4 2024 /bin -> usr/bin -I: user script /srv/workspace/pbuilder/17719/tmp/hooks/D02_print_environment finished + lrwxrwxrwx 1 root root 7 Aug 4 21:30 /bin -> usr/bin +I: user script /srv/workspace/pbuilder/58132/tmp/hooks/D02_print_environment finished -> Attempting to satisfy build-dependencies -> Creating pbuilder-satisfydepends-dummy package Package: pbuilder-satisfydepends-dummy @@ -659,7 +691,7 @@ Get: 536 http://deb.debian.org/debian unstable/main i386 python3-mpmath all 1.3.0-1 [419 kB] Get: 537 http://deb.debian.org/debian unstable/main i386 python3-packaging all 24.1-1 [45.8 kB] Get: 538 http://deb.debian.org/debian unstable/main i386 python3-sympy all 1.13.3-1 [4147 kB] -Fetched 222 MB in 5s (45.1 MB/s) +Fetched 222 MB in 12s (18.0 MB/s) debconf: delaying package configuration, since apt-utils is not installed Selecting previously unselected package libpython3.12-minimal:i386. (Reading database ... (Reading database ... 5% (Reading database ... 10% (Reading database ... 15% (Reading database ... 20% (Reading database ... 25% (Reading database ... 30% (Reading database ... 35% (Reading database ... 40% (Reading database ... 45% (Reading database ... 50% (Reading database ... 55% (Reading database ... 60% (Reading database ... 65% (Reading database ... 70% (Reading database ... 75% (Reading database ... 80% (Reading database ... 85% (Reading database ... 90% (Reading database ... 95% (Reading database ... 100% (Reading database ... 19955 files and directories currently installed.) @@ -2421,8 +2453,8 @@ Setting up tzdata (2024b-3) ... Current default time zone: 'Etc/UTC' -Local time is now: Mon Dec 15 00:51:30 UTC 2025. -Universal Time is now: Mon Dec 15 00:51:30 UTC 2025. +Local time is now: Mon Nov 11 18:38:31 UTC 2024. +Universal Time is now: Mon Nov 11 18:38:31 UTC 2024. Run 'dpkg-reconfigure tzdata' if you wish to change it. Setting up libxcb-present0:i386 (1.17.0-2+b1) ... @@ -2875,7 +2907,11 @@ Building tag database... -> Finished parsing the build-deps I: Building the package -I: Running cd /build/reproducible-path/octave-symbolic-3.2.1/ && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games" HOME="/nonexistent/first-build" dpkg-buildpackage -us -uc -b && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games" HOME="/nonexistent/first-build" dpkg-genchanges -S > ../octave-symbolic_3.2.1-3_source.changes +I: user script /srv/workspace/pbuilder/58132/tmp/hooks/A99_set_merged_usr starting +Not re-configuring usrmerge for unstable +I: user script /srv/workspace/pbuilder/58132/tmp/hooks/A99_set_merged_usr finished +hostname: Name or service not known +I: Running cd /build/reproducible-path/octave-symbolic-3.2.1/ && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path" HOME="/nonexistent/second-build" dpkg-buildpackage -us -uc -b && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path" HOME="/nonexistent/second-build" dpkg-genchanges -S > ../octave-symbolic_3.2.1-3_source.changes dpkg-buildpackage: info: source package octave-symbolic dpkg-buildpackage: info: source version 3.2.1-3 dpkg-buildpackage: info: source distribution unstable @@ -2914,206 +2950,1627 @@ Checking package... Run the unit tests... Checking m files ... -[inst/@sym/gammainc.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/gammainc.m -***** assert (isequal (gammainc (sym(0), 1), sym(0))) +[inst/@double/dilog.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/dilog.m +***** test + x = 1.1; + y = sym(11)/10; + A = dilog (x); + B = double (dilog (y)); + assert (A, B, -4*eps); Symbolic pkg v3.2.1: Python communication link active, SymPy v1.13.3. -***** assert (isequal (gammainc (sym(0), 2), sym(0))) -***** assert (isequal (gammainc (sym('oo'), 1), sym(1))) -***** assert (isequal (gammainc (sym(0), 1, 'upper'), sym(1))) -***** assert (isequal (gammainc (sym(0), 2, 'upper'), sym(1))) -***** assert (isequal (gammainc (sym('oo'), 1, 'upper'), sym(0))) ***** test - % default is lower - syms x a - assert (isequal (gammainc (x, a), gammainc(x, a, 'lower'))) + y = [2 2 sym(pi); exp(sym(1)) 5 6]; + x = double (y); + A = dilog (x); + B = double (dilog (y)); + assert (A, B, -eps); ***** test - % compare to double - x = 5; a = 1; - A = gammainc (x, a); - B = double (gammainc (sym(x), a)); - assert(A, B, -eps) + % maple: + % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; + % > for a in A do evalf(dilog(a)) end do; + x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; + A = [ -0.59248494924959145800 - 1.5760154034463234224*1i + -1.0549087538833908441 - 3.8759788000863368495*1i + -12.192421669033171348 + -2.9195729380904939394 - 3.9540920181102973073*1i + 1.6459519160623984119 - 0.00032335296277550987686*1i + -1.5445800511775466879 + 9.4256034277816069684*1i ]; + B = dilog (x); + assert (A, B, -eps) +***** xtest + % https://github.com/fredrik-johansson/mpmath/issues/473 + assert (isinf (dilog (inf))) +!!!!! known failure +assert (isinf (dilog (inf))) failed +***** assert (isnan (dilog (-inf))) +warning: test: file /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/dilog.m leaked file descriptors +5 tests, 4 passed, 1 known failure, 0 skipped +[inst/@double/coshint.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/coshint.m +***** error coshint (1, 2) ***** test - % compare to double where gamma(a) != 1 - x = 5; a = 3; - A = gammainc (x, a); - B = double (gammainc (sym(x), a)); - assert(A, B, -eps) + x = 1.1; + y = sym(11)/10; + A = coshint (x); + B = double (coshint (y)); + assert (A, B, -4*eps); ***** test - % compare to double - x = 100; a = 1; - A = gammainc (x, a); - B = double (gammainc (sym(x), a)); - assert(A, B, -eps) + y = [2 3 sym(pi); exp(sym(1)) 5 6]; + x = double (y); + A = coshint (x); + B = double (coshint (y)); + assert (A, B, -4*eps); ***** test - % compare to double - xs = sym(1)/1000; x = 1/1000; a = 1; - A = gammainc (x, a); - B = double (gammainc (xs, a)); - assert(A, B, -eps) + % maple: + % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; + % > for a in A do evalf(Chi(a)) end do; + x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; + A = [ 0.58447599687824767874 + 1.8682915044330306402*1i + -0.63131069034703116988 + 1.8986171211850702957*1i + 0.13577763724269399110e42 + -0.045456433004455372635 + 1.5707963267948966192*1i + -8.6330747070747332203 + 3.1315929868531280002*1i + 0.74701205140887966531e7 + 0.10381444259644068585e8*1i ]; + B = coshint (x); + assert (A, B, -eps) +***** assert (coshint (inf), inf) +***** assert (isinf (coshint (-inf))) +***** assert (imag (coshint (-inf)), pi) +7 tests, 7 passed, 0 known failure, 0 skipped +[inst/@double/bernoulli.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/bernoulli.m +***** error bernoulli (1, 2, 3) +***** error bernoulli ([1 2], [1 2 3]) +***** error bernoulli ([1 2], [1; 2]) +***** assert (bernoulli (0), 1) +***** assert (bernoulli (3), 0) ***** test - % compare to double - x = 5; a = 1; - A = gammainc (x, a, 'upper'); - B = double (gammainc (sym(x), a, 'upper')); - assert(A, B, -10*eps) + % two different definitions in literature + assert (abs (bernoulli (1)), 0.5, -eps) +***** xtest + % we want to use B_1 = 1/2, possible with a version-specific filter + assert (bernoulli (1), 0.5, -eps) +!!!!! known failure +ASSERT errors for: assert (bernoulli (1),0.5,-eps) + + Location | Observed | Expected | Reason + () -0.5 0.5 Rel err 2 exceeds tol 2.2204e-16 by 2 ***** test - % compare to double - x = 10; a = 1; - A = gammainc (x, a, 'upper'); - B = double (gammainc (sym(x), a, 'upper')); - assert(A, B, -10*eps) + n = sym(88); + m = 88; + A = bernoulli (m); + B = double (bernoulli (n)); + assert (A, B, -eps); ***** test - % compare to double - x = 40; a = 1; - A = gammainc (x, a, 'upper'); - B = double (gammainc (sym(x), a, 'upper')); - assert(A, B, -10*eps) + m = [0 2; 3 4]; + n = sym(m); + A = bernoulli (m); + B = double (bernoulli (n)); + assert (isequal (A, B)); ***** test - % compare to double - xs = sym(1)/1000; x = 1/1000; a = 1; - A = gammainc (x, a, 'upper'); - B = double (gammainc (xs, a, 'upper')); - assert(A, B, -eps) + y = sym(19)/10; + n = sym(2); + x = 1.9; + m = 2; + A = bernoulli (m, x); + B = double (bernoulli (n, y)); + assert (A, B, -eps); ***** test - % vectorized - P = gammainc([sym(pi) 2], [1 3]); - expected = [gammainc(pi, sym(1)) gammainc(2, sym(3))]; - assert (isequal (P, expected)) + assert (isequal (bernoulli (4, inf), inf)) + assert (isequal (bernoulli (4, -inf), inf)) +***** xtest + % still broken? + assert (isequal (bernoulli (3, inf), inf)) + assert (isequal (bernoulli (3, -inf), -inf)) ***** test - % vectorized - P = gammainc(sym(pi), [1 3]); - expected = [gammainc(sym(pi), 1) gammainc(sym(pi), 3)]; - assert (isequal (P, expected)) + assert (isnan (bernoulli(3, nan))) + assert (isnumeric (bernoulli(3, nan))) ***** test - % vectorized - P = gammainc([sym(pi) 2], 1); - expected = [gammainc(pi, sym(1)) gammainc(2, sym(1))]; - assert (isequal (P, expected)) + % maple, complex input + A = 34.21957245745810513 - 130.0046256649829101i; + B = bernoulli(7, 2.123 + 1.234i); + assert (A, B, -5*eps); ***** test - % round trip - syms x a - f = gammainc (x, a, 'upper'); - h = function_handle (f, 'vars', [x a]); - A = h (1.1, 2); - B = gammainc (1.1, 2, 'upper'); - assert (A, B) + % x matrix, m scalar + y = [1 2 sym(pi); exp(sym(1)) 5 6]; + n = sym(2); + x = double (y); + m = 2; + A = bernoulli (m, x); + B = double (bernoulli (n, y)); + assert (A, B, -eps); ***** test - % round trip - syms x a - f = gammainc (x, a, 'lower'); - h = function_handle (f, 'vars', [x a]); - A = h (1.1, 2); - B = gammainc (1.1, 2, 'lower'); - assert (A, B) + % m matrix, x scalar + m = [1 2 3; 4 5 6]; + n = sym(m); + y = sym(21)/10; + x = 2.1; + A = bernoulli (m, x); + B = double (bernoulli (n, y)); + assert (A, B, -3*eps); +16 tests, 15 passed, 1 known failure, 0 skipped +[inst/@double/pochhammer.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/pochhammer.m +***** error pochhammer (1) +***** error pochhammer (1, 2, 3) +***** error pochhammer ([1 2], [1 2 3]) +***** error pochhammer ([1 2], [1; 2]) ***** test - % round trip - syms x a - f = gammainc (x, a, 'upper'); - h = function_handle (f, 'vars', [x a]); - A = h (1.1, 2.2); - B = gammainc (1.1, 2.2, 'upper'); - assert (A, B) + y = sym(11)/10; + t = sym(3); + x = 1.1; + s = 3; + A = pochhammer (x, s); + B = double (pochhammer (y, t)); + assert (A, B, -2*eps); ***** test - % round trip - syms x a - f = gammainc (x, a, 'lower'); - h = function_handle (f, 'vars', [x a]); - A = h (1.1, 2.2); - B = gammainc (1.1, 2.2, 'lower'); - assert (A, B) -warning: test: file /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/gammainc.m leaked file descriptors -22 tests, 22 passed, 0 known failure, 0 skipped -[inst/@sym/pochhammer.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/pochhammer.m -***** error pochhammer (sym(1)) -***** error pochhammer (sym(1), 2, 3) -***** assert (isequal (pochhammer (sym(3), 4), sym(360))) -***** assert (isequal (pochhammer (sym([2 3]), 3), sym([24 60]))) + % maple + A = 256.798558090310131720; + B = pochhammer (18.1, 1.9); + assert (A, B, -20*eps) +***** test + % maple, complex inputs> + A = 2.67921619474318221972 + 1.96716724764630702653*1i; + B = pochhammer (12.1+3.1*i, 0.5+0.2i); + assert (A, B, -4*eps); +***** test + % maple, matrix inputs + A = [5.61467232547723663908 20.6144884613920190965]; + B = pochhammer ([0.9 0.8], [3.1 4.2]); + assert (A, B, -3*eps); +***** test + % x matrix, s scalar + y = [1 2 sym(pi); exp(sym(1)) 5 6]; + t = sym(2); + x = double (y); + s = 2; + A = pochhammer (s, x); + B = double (pochhammer (t, y)); + assert (A, B, -3*eps); +***** test + % s matrix, x scalar + t = [1 2 sym(pi); exp(sym(1)) 5 6]; + y = sym(2); + s = double (t); + x = 2; + A = pochhammer (s, x); + B = double (pochhammer (t, y)); + assert (A, B, -5*eps); +10 tests, 10 passed, 0 known failure, 0 skipped +[inst/@double/chebyshevU.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/chebyshevU.m +***** error chebyshevU (1) +***** error chebyshevU (1, 2, 3) +***** error chebyshevU ([1 2], [1 2 3]) +***** error chebyshevU ([1 2], [1; 2]) +***** test + y = sym(11)/10; + t = sym(2); + x = 1.1; + s = 2; + A = chebyshevU (s, x); + B = double (chebyshevU (t, y)); + assert (A, B, -2*eps); +***** test + % maple + A = 1.661891066691338157; + B = chebyshevU (18.1, 0.9); + assert (A, B, -3*eps) +***** test + % maple, complex inputs> + % ChebyshevU(12.1+3.1*I, 0.5+0.2*I); + A = 1.046959313670290818 - 0.03386773634958834846*1i; + B = chebyshevU (12.1+3.1*i, 0.5+0.2i); + assert (A, B, -3*eps); +***** test + % maple, matrix inputs + A = [2.2543638828875776000 -1.3872651600553574400]; + B = chebyshevU ([16 17], [0.9 0.8]); + assert (A, B, -10*eps); +***** test + % x matrix, s scalar + y = [1 2 sym(pi); exp(sym(1)) 5 6]; + t = sym(2); + x = double (y); + s = 2; + A = chebyshevU (s, x); + B = double (chebyshevU (t, y)); + assert (A, B, -eps); +***** test + % s matrix, x scalar + t = [1 2 sym(pi); exp(sym(1)) 5 6]; + y = sym(2); + s = double (t); + x = 2; + A = chebyshevU (s, x); + B = double (chebyshevU (t, y)); + assert (A, B, -2*eps); +***** xtest + % https://github.com/fredrik-johansson/mpmath/issues/469 + assert (chebyshevU (4, inf), inf) + assert (chebyshevU (4, -inf), inf) + assert (chebyshevU (3, inf), inf) + assert (chebyshevU (3, -inf), -inf) +!!!!! known failure +ASSERT errors for: assert (chebyshevU (4, inf),inf) + + Location | Observed | Expected | Reason + () 5 Inf 'Inf' mismatch +11 tests, 10 passed, 1 known failure, 0 skipped +[inst/@double/adjoint.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/adjoint.m +***** test + M = [1 2; 3 4]; + A = [4 -2; -3 1]; + assert (isequal (adjoint (M), A)); +***** test + assert (isequal (adjoint (42), 1)); +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@double/fresnels.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/fresnels.m +***** error fresnels (1, 2) +***** test + x = 1.1; + y = sym(11)/10; + A = fresnels (x); + B = double (fresnels (y)); + assert (A, B, -4*eps); +***** test + y = [2 3 sym(pi); exp(sym(1)) 5 6]; + x = double (y); + A = fresnels (x); + B = double (fresnels (y)); + assert (A, B, -4*eps); +***** test + % maple: + % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; + % > for a in A do evalf(FresnelS(a)) end do; + x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; + A = [ 36.725464883991438430 + 15.587751104404587334*1i + 0.12213736710980573217e13 - 0.47688568479924574726e12*1i + 0.49681690114783755327 + -0.46816997858488224040*1i + -0.52344169596561937423e-12 + 0.15707439669173367248e-13*1i + 0.75738824160998910399e24 + 0.15391592966931193100e26*1i ]; + B = fresnels (x); + assert (A, B, -eps) +***** assert (fresnels (inf), 0.5) +***** assert (fresnels (-inf), -0.5) +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@double/logint.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/logint.m +***** error logint (1, 2) +***** test + x = 1.1; + y = sym(11)/10; + A = logint (x); + B = double (logint (y)); + assert (A, B, -4*eps); +***** test + y = [2 3 sym(pi); exp(sym(1)) 5 6]; + x = double (y); + A = logint (x); + B = double (logint (y)); + assert (A, B, -4*eps); +***** test + % maple: + % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; + % > for a in A do evalf(Li(a)) end do; + x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; + A = [ 1.3876787420229375511 + 2.5087546988592328752*1i + 1.6987684473874802274 + 4.5936366057115204667*1i + 30.126141584079629926 + 3.4936715673748995398 + 5.5260023797127391973*1i + 0.90264689772681592152e-5 + 3.1415953634267361942*1i + -2.3996350854560916779 - 7.6971739096353664559*1i ]; + B = logint (x); + assert (A, B, -eps) +***** assert (logint (inf), inf) +***** assert (isnan (logint (-inf))) +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@double/sinint.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/sinint.m +***** error sinint (1, 2) +***** test + x = 1.1; + y = sym(11)/10; + A = sinint (x); + B = double (sinint (y)); + assert (A, B, -4*eps); +***** test + y = [2 3 sym(pi); exp(sym(1)) 5 6]; + x = double (y); + A = sinint (x); + B = double (sinint (y)); + assert (A, B, -4*eps); +***** assert (sinint (0), 0) +***** assert (sinint (inf), pi/2) +***** assert (sinint (-inf), -pi/2) +***** assert (sinint (1), 0.9460830703671830149414, -2*eps) +***** assert (sinint (-1), -0.9460830703671830149414, -2*eps) +***** assert (sinint (pi), 1.851937051982466170361, -2*eps) +***** assert (sinint (-pi), -1.851937051982466170361, -2*eps) +***** assert (sinint (300), 1.5708810882137495193, -2*eps) +***** assert (sinint (1e4), 1.5708915453859619157, -2*eps) +***** assert (sinint (20i), 1.2807826332028294459e7*1i, -2*eps) +***** test + % maple: + % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; + % > for a in A do evalf(Si(a)) end do; + x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; + A = [ 1.6782404878293681180 + 2.0396845546022061045*1i + -18.154174221650281533 + 1.6146414539230479060*1i + 1.5622254668890562934 + 1246.1144901994233444*1i + -0.000099999999944461111128 + 0.99999999833338888972e-6*1i + -1.5386156269726011209 - 0.053969388020443786229*1i ]; + B = sinint (x); + assert (A, B, -eps) +14 tests, 14 passed, 0 known failure, 0 skipped +[inst/@double/cosint.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/cosint.m +***** error cosint (1, 2) +***** test + x = 1.1; + y = sym(11)/10; + A = cosint (x); + B = double (cosint (y)); + assert (A, B, -4*eps); +***** test + y = [2 3 sym(pi); exp(sym(1)) 5 6]; + x = double (y); + A = cosint (x); + B = double (cosint (y)); + assert (A, B, -4*eps); +***** test + % maple: + % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; + % > for a in A do evalf(Ci(a)) end do; + x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; + A = [ 2.0302963932917216378 - 0.15190715517585688438*1i + 1.6153896382910774851 + 19.725754055338264980*1i + -0.0051488251426104921444 + 1246.1144860424544147 + 1.5707963267948966192*1i + -8.6330747120742332203 + 3.1315929869531280002*1i + 0.069822228467306149311 - 3.1184744625477294643*1i ]; + B = cosint (x); + assert (A, B, -eps) +***** xtest + % is it nan or -inf? SymPy says zoo. + assert (isnan (cosint (0))) +!!!!! known failure +assert (isnan (cosint (0))) failed +***** assert (cosint (inf), 0) +***** assert (cosint (-inf), pi*1i, -eps) +***** assert (cosint (1), 0.33740392290096813466, -eps) +***** assert (cosint (-1), 0.33740392290096813466 + pi*1i, -eps) +***** assert (cosint (pi), 0.073667912046425485978, -5*eps) +***** assert (cosint (-pi), 0.07366791204642548597821 + pi*1i, -5*eps) +***** assert (cosint (300), -3.3321999185921117800e-3, -2*eps) +***** assert (cosint (1e4), -3.0551916724485212665e-5, -2*eps) +***** assert (cosint (1 + 1i), 0.8821721805559363250506+0.2872491335199559395273*1i, eps) +***** assert (cosint (1i), 0.8378669409802082408947 + pi/2*1i, -2*eps) +***** test + % compare both sinint and cosint to expint + x = pi; + C1 = cosint (x); + S1 = sinint (x); + R = expint (1i*x); + C2 = -real (R); + S2 = imag (R) + pi/2; + assert (C1, C2, -100*eps); + assert (S1, S2, -100*eps); +16 tests, 15 passed, 1 known failure, 0 skipped +[inst/@double/sinhint.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/sinhint.m +***** error sinhint (1, 2) +***** test + x = 1.1; + y = sym(11)/10; + A = sinhint (x); + B = double (sinhint (y)); + assert (A, B, -4*eps); +***** test + y = [2 3 sym(pi); exp(sym(1)) 5 6]; + x = double (y); + A = sinhint (x); + B = double (sinhint (y)); + assert (A, B, -4*eps); +***** test + % maple: + % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; + % > for a in A do evalf(Shi(a)) end do; + x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; + A = [ 0.45769171128668800567 + 1.8332099215048436239*1i + 0.60888490416819746440 + 1.2482232175376056201*1i + 0.13577763724269399110e42 + 1.6583475942188740493*1i + -0.00010000000005553888891 + 0.10000000016666111119e-5*1i + -0.74701205140887967022e7 - 0.10381447401236722090e8*1i ]; + B = sinhint (x); + assert (A, B, -eps) +***** assert (sinhint (inf), inf) +***** assert (sinhint (-inf), -inf) +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@double/euler.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/euler.m +***** error euler (1, 2, 3) +***** error euler ([1 2], [1 2 3]) +***** error euler ([1 2], [1; 2]) +***** assert (isequal (euler (0), 1)) +***** assert (isequal (euler (1), 0)) +***** assert (isequal (euler (10), -50521)) +***** test + n = sym(88); + m = 88; + A = euler (m); + B = double (euler (n)); + assert (A, B, -eps); +***** test + m = [0 1; 2 4]; + n = sym(m); + A = euler (m); + B = double (euler (n)); + assert (isequal (A, B)); +***** test + y = sym(19)/10; + n = sym(2); + x = 1.9; + m = 2; + A = euler (m, x); + B = double (euler (n, y)); + assert (A, B, -eps); +***** test + % correct behaviour at floating point infinity + assert (isequal (euler (4, inf), inf)) + assert (isequal (euler (4, -inf), inf)) + assert (isequal (euler (3, inf), inf)) + assert (isequal (euler (3, -inf), -inf)) +***** test + assert (isnan (euler(3, nan))) + assert (isnumeric (euler(3, nan))) +***** test + % maple, complex input + A = 113.33970046079423204 - 46.991080726974811540i; + B = euler(7, 2.12345 + 1.23i); + assert (A, B, -eps); +***** test + % maple, complex input, large m, small x + A = 0.18034673393294025238e276 + 0.27756266681280689172e276*i; + B = euler (200, 0.123+0.234i); + assert (A, B, -eps); +***** test + % x matrix, m scalar + y = [1 2 sym(pi); exp(sym(1)) 5 6]; + n = sym(2); + x = double (y); + m = 2; + A = euler (m, x); + B = double (euler (n, y)); + assert (A, B, -eps); +***** test + % m matrix, x scalar + m = [1 2 3; 4 5 6]; + n = sym(m); + y = sym(21)/10; + x = 2.1; + A = euler (m, x); + B = double (euler (n, y)); + assert (A, B, -3*eps); +15 tests, 15 passed, 0 known failure, 0 skipped +[inst/@double/polylog.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/polylog.m +***** error polylog (1) +***** error polylog (1, 2, 3) +***** error polylog ([1 2], [1 2 3]) +***** error polylog ([1 2], [1; 2]) +***** test + y = sym(11)/10; + t = sym(2); + x = 1.1; + s = 2; + A = polylog (s, x); + B = double (polylog (t, y)); + assert (A, B, -eps); +***** test + % maple + A = 2.3201804233130983964 - 3.4513922952232026614*1i; + B = polylog (2, 3); + assert (A, B, -eps) +***** test + % maple, complex inputs + A = -11.381456201167411758 + 6.2696695219721651947*1i; + B = polylog (1+2i, 3+4i); + assert (A, B, -eps); +***** test + % maple, matrix inputs + A1 = 0.47961557317612748431 - 0.52788287823025778869*1i; + A2 = -0.0049750526563452645369 - 0.024579343612396884851*1i; + B = polylog ([-1-2i -3], [30+40i 40i]); + assert ([A1 A2], B, -eps); +***** test + % x matrix, s scalar + y = [1 2 sym(pi); exp(sym(1)) 5 6]; + t = sym(2); + x = double (y); + s = 2; + A = polylog (s, x); + B = double (polylog (t, y)); + assert (A, B, -eps); +***** test + % s matrix, x scalar + t = [1 2 sym(pi); exp(sym(1)) 5 6]; + y = sym(2); + s = double (t); + x = 2; + A = polylog (s, x); + B = double (polylog (t, y)); + assert (A, B, -eps); +10 tests, 10 passed, 0 known failure, 0 skipped +[inst/@double/fresnelc.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/fresnelc.m +***** error fresnelc (1, 2) +***** test + x = 1.1; + y = sym(11)/10; + A = fresnelc (x); + B = double (fresnelc (y)); + assert (A, B, -4*eps); +***** test + y = [2 3 sym(pi); exp(sym(1)) 5 6]; + x = double (y); + A = fresnelc (x); + B = double (fresnelc (y)); + assert (A, B, -4*eps); +***** test + % maple: + % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; + % > for a in A do evalf(FresnelC(a)) end do; + x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; + A = [ 16.087871374125480424 - 36.225687992881650217*1i + 0.47688568479874574722e12 + 0.12213736710985573216e13*1i + 0.49999989867881789756 + 0.49989869420551572361*1i + -0.000099999999999999997535 + 0.99999999999999987665e-6*1i + 0.15391592966931193100e26 - 0.75738824160998910388e24*1i ]; + B = fresnelc (x); + assert (A, B, -eps) +***** assert (fresnelc (inf), 0.5) +***** assert (fresnelc (-inf), -0.5) +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@double/chebyshevT.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/chebyshevT.m +***** error chebyshevT (1) +***** error chebyshevT (1, 2, 3) +***** error chebyshevT ([1 2], [1 2 3]) +***** error chebyshevT ([1 2], [1; 2]) +***** test + y = sym(11)/10; + t = sym(2); + x = 1.1; + s = 2; + A = chebyshevT (s, x); + B = double (chebyshevT (t, y)); + assert (A, B, -2*eps); +***** test + % maple + A = -0.304681164165948269030369; + B = chebyshevT (18.1, 0.9); + assert (A, B, -10*eps) +***** test + % maple, complex inputs + % ChebyshevT(12.1+3.1*I, 0.5+0.2*I); + A = 0.637229289490379273451 - 0.475324703778957991318*1i; + B = chebyshevT (12.1+3.1*i, 0.5+0.2i); + assert (A, B, -5*eps); +***** test + % maple, matrix inputs + A = [0.59523064198266880000 0.57727442996887552000]; + B = chebyshevT ([16 17], [0.9 0.7]); + assert (A, B, -10*eps); +***** test + % x matrix, s scalar + y = [1 2 sym(pi); exp(sym(1)) 5 6]; + t = sym(2); + x = double (y); + s = 2; + A = chebyshevT (s, x); + B = double (chebyshevT (t, y)); + assert (A, B, -eps); +***** test + % s matrix, x scalar + t = [1 2 sym(pi); exp(sym(1)) 5 6]; + y = sym(2); + s = double (t); + x = 2; + A = chebyshevT (s, x); + B = double (chebyshevT (t, y)); + assert (A, B, -eps); +***** xtest + % https://github.com/fredrik-johansson/mpmath/issues/469 + assert (chebyshevT (4, inf), inf) + assert (chebyshevT (4, -inf), inf) + assert (chebyshevT (3, inf), inf) + assert (chebyshevT (3, -inf), -inf) +!!!!! known failure +ASSERT errors for: assert (chebyshevT (4, inf),inf) + + Location | Observed | Expected | Reason + () 1 Inf 'Inf' mismatch +11 tests, 10 passed, 1 known failure, 0 skipped +[inst/@double/zeta.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/zeta.m +***** error zeta (1, 2, 3) +***** assert (isnan (zeta (nan))) +***** test + x = 1.1; + y = sym(11)/10; + A = zeta (x); + B = double (zeta (y)); + assert (A, B, -4*eps); +***** test + y = [2 3 sym(pi); exp(sym(1)) 5 6]; + x = double (y); + A = zeta (x); + B = double (zeta (y)); + assert (A, B, -4*eps); +***** test + % maple: + % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; + % > for a in A do evalf(Zeta(a)) end do; + x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; + A = [ 0.59816556976238173670 - 0.35185474521784529050*1i + 0.21425967567391921717 + 0.52503846985036050707*1i + 1.0 + 1.7564685929749629608 - 0.10151198543617116894*1i + -0.49990811617645824900 - 0.91873792757763831501e-6*1i + 175.09070083717643866 - 71.512541417467273425*1i ]; + B = zeta (x); + assert (A, B, -eps) +***** assert (zeta (inf), 1.0) +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@double/harmonic.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/harmonic.m +***** error harmonic (1, 2) +***** test + x = 1.1; + y = sym(11)/10; + A = harmonic (x); + B = double (harmonic (y)); + assert (A, B, -4*eps); +***** test + y = [2 3 sym(pi); exp(sym(1)) 5 6]; + x = double (y); + A = harmonic (x); + B = double (harmonic (y)); + assert (A, B, -4*eps); +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/vpasolve.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/vpasolve.m +***** test + syms x + vpi = vpa(sym(pi), 64); + e = tan(x/4) == 1; + q = vpasolve(e, x, 3.0); + w = q - vpi ; + assert (double(w) < 1e-30) +***** test + syms x + vpi = vpa(sym(pi), 64); + e = tan(x/4) == 1; + q = vpasolve(e, x); + w = q - vpi; + assert (double(w) < 1e-30) + q = vpasolve(e); + w = q - vpi; + assert (double(w) < 1e-30) +***** test + % very accurate pi + syms x + e = tan(x/4) == 1; + m = digits(256); + q = vpasolve(e, x, 3); + assert (double(abs(sin(q))) < 1e-256) + digits(m); +***** test + % very accurate sqrt 2 + syms x + e = x*x == 2; + m = digits(256); + q = vpasolve(e, x, 1.5); + assert (double(abs(q*q - 2)) < 1e-256) + digits(m); +***** test + % very accurate sqrt pi + % (used to fail https://github.com/sympy/sympy/issues/8564) + syms x + e = x*x == sym(pi); + m = digits(256); + q = vpasolve(e, x, 3); + assert (double(abs(sin(q*q))) < 1e-256) + digits(m); +***** test + syms x + r = vpasolve(x^2 + 2 == 0, x, 1i); + assert (double (imag(r)^2 - 2), 0, 1e-32) + assert (double (real(r)^2), 0, 1e-32) + r = vpasolve(x^2 + 2 == 0, x, -3i + 5); + assert (double (imag(r)^2 - 2), 0, 1e-32) + assert (double (real(r)^2), 0, 1e-32) +***** test + % system + syms x y + f = 3*x^2 - 2*y^2 - 1; + g = x^2 - 2*x + y^2 + 2*y - 8; + r = vpasolve([f; g], [x; y], sym([-1; 1])); + assert (isa (r, 'sym')) + assert (numel (r) == 2) +***** test + % system, double guess + syms x y + f = 3*x^2 - 2*y^2 - 1; + g = x^2 - 2*x + y^2 + 2*y - 8; + r = vpasolve([f; g], [x; y], [-1.1 1.2]); +***** test + % system, double guess + syms x y + f = 3*x^2 - 2*y^2 - 1; + g = x^2 - 2*x + y^2 + 2*y - 8; + r1 = vpasolve([f; g], [x; y], [-1.1]); + r2 = vpasolve([f; g], [x; y], [-1.1 -1.1]); + assert (isequal (r1, r2)) +***** test + % system, more eqns than unknowns + syms x y + eqns = [x^3 - x - y == 0; y*exp(x) == 16; log(y) + x == 4*log(sym(2))]; + r = vpasolve (eqns, [x; y], [1; 1]); + A = subs (lhs (eqns), [x; y], r); + err = A - [0; 16; 4*log(sym(2))]; + assert (double (err), zeros (size (err)), 1e-31) +:7: SymPyDeprecationWarning: + +non-Expr objects in a Matrix is deprecated. Matrix represents +a mathematical matrix. To represent a container of non-numeric +entities, Use a list of lists, TableForm, NumPy array, or some +other data structure instead. + +See https://docs.sympy.org/latest/explanation/active-deprecations.html#deprecated-non-expr-in-matrix +for details. + +This has been deprecated since SymPy version 1.9. It +will be removed in a future version of SymPy. + +10 tests, 10 passed, 0 known failure, 0 skipped +[inst/pycall_sympy__.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/pycall_sympy__.m +***** test + % general test + x = 10; y = 6; + cmd = '(x,y) = _ins; return (x+y,x-y)'; + [a,b] = pycall_sympy__ (cmd, x, y); + assert (a == x + y && b == x - y) +***** test + % bool + assert (pycall_sympy__ ('return True,')) + assert (~pycall_sympy__ ('return False,')) +***** test + % float + assert (abs(pycall_sympy__ ('return 1.0/3,') - 1/3) < 1e-15) +***** test + % int + r = pycall_sympy__ ('return 123456'); + assert (r == 123456) + assert (isinteger (r)) +***** test + % string + x = 'octave'; + cmd = 's = _ins[0]; return s.capitalize(),'; + y = pycall_sympy__ (cmd, x); + assert (strcmp(y, 'Octave')) +***** test + % string with escaped newlines, comes back as escaped newlines + x = 'a string\nbroke off\nmy guitar\n'; + y = pycall_sympy__ ('return _ins', x); + assert (strcmp(y, x)) +***** test + % string with actual newlines, comes back as actual newlines + x = sprintf('a string\nbroke off\nmy guitar\n'); + y = pycall_sympy__ ('return _ins', x); + y2 = strrep(y, sprintf('\n'), sprintf('\r\n')); % windows + assert (strcmp(x, y) || strcmp(x, y2)) +***** test + % cmd string with newlines, works with cell + y = pycall_sympy__ ('return "string\nbroke",'); + y2 = sprintf('string\nbroke'); + y3 = strrep(y2, sprintf('\n'), sprintf('\r\n')); % windows + assert (strcmp(y, y2) || strcmp(y, y3)) +***** test + % string with XML escapes + x = '<> >< <<>>'; + y = pycall_sympy__ ('return _ins', x); + assert (strcmp(y, x)) + x = '&'; + y = pycall_sympy__ ('return _ins', x); + assert (strcmp(y, x)) +***** test + % strings with double quotes + x = 'a\"b\"c'; + y = pycall_sympy__ ('return _ins', x); + assert (strcmp(y, x)) + x = '\"'; + y = pycall_sympy__ ('return _ins', x); + assert (strcmp(y, x)) +***** test + % cmd has double quotes, these must be escaped by user + % (of course: she is writing python code) + expy = 'a"b"c'; + y = pycall_sympy__ ('return "a\"b\"c",'); + assert (strcmp(y, expy)) +***** test + % strings with quotes + x = 'a''b'; % this is a single quote + y = pycall_sympy__ ('return _ins', x); + assert (strcmp(y, x)) +***** test + % strings with quotes + x = '\"a''b\"c''\"d'; + y = pycall_sympy__ ('return _ins[0]', x); + assert (strcmp(y, x)) +***** test + % strings with quotes + expy = '"a''b"c''"d'; + y = pycall_sympy__ ('s = "\"a''b\"c''\"d"; return s'); + assert (strcmp(y, expy)) +***** test + % strings with printf escapes + x = '% %% %%% %%%% %s %g %%s'; + y = pycall_sympy__ ('return _ins', x); + assert (strcmp(y, x)) +***** test + % cmd with printf escapes + x = '% %% %%% %%%% %s %g %%s'; + y = pycall_sympy__ (['return "' x '",']); + assert (strcmp(y, x)) +***** test + % cmd w/ backslash and \n must be escaped by user + expy = 'a\b\\c\nd\'; + y = pycall_sympy__ ('return "a\\b\\\\c\\nd\\",'); + assert (strcmp(y, expy)) +***** test + % slashes + x = '/\\ // \\\\ \\/\\/\\'; + z = '/\ // \\ \/\/\'; + y = pycall_sympy__ ('return _ins', x); + assert (strcmp(y, x)) +***** test + % slashes + z = '/\ // \\ \/\/\'; + y = pycall_sympy__ ('return "/\\ // \\\\ \\/\\/\\"'); + assert (strcmp(y, z)) +***** test + % strings with special chars + x = '!@#$^&* you!'; + y = pycall_sympy__ ('return _ins', x); + assert (strcmp(y, x)) + x = '~-_=+[{]}|;:,.?'; + y = pycall_sympy__ ('return _ins', x); + assert (strcmp(y, x)) +***** xtest + % string with backtick trouble for system -c (sysoneline) + x = '`'; + y = pycall_sympy__ ('return _ins', x); + assert (strcmp(y, x)) +***** test + % unicode + s1 = '我爱你'; + cmd = 'return u"\u6211\u7231\u4f60",'; + s2 = pycall_sympy__ (cmd); + assert (strcmp (s1, s2)) +***** test + % unicode with \x + s1 = '我'; + cmd = 'return b"\xe6\x88\x91".decode("utf-8")'; + s2 = pycall_sympy__ (cmd); + assert (strcmp (s1, s2)) +***** test + % unicode with \x and some escaped backslashes + s1 = '\我\'; + cmd = 'return b"\\\xe6\x88\x91\\".decode("utf-8")'; + s2 = pycall_sympy__ (cmd); + assert (strcmp (s1, s2)) +***** xtest + % unicode passthru + s = '我爱你'; + s2 = pycall_sympy__ ('return _ins', s); + assert (strcmp (s, s2)) + s = '我爱你<>\&//\#%% %\我'; + s2 = pycall_sympy__ ('return _ins', s); + assert (strcmp (s, s2)) +***** xtest + % unicode w/ slashes, escapes + s = '我<>\&//\#%% %\我'; + s2 = pycall_sympy__ ('return "我<>\\&//\\#%% %\\我"'); + assert (strcmp (s, s2)) +***** test + % list, tuple + assert (isequal (pycall_sympy__ ('return [1,2,3],'), {1, 2, 3})) + assert (isequal (pycall_sympy__ ('return (4,5),'), {4, 5})) + assert (isequal (pycall_sympy__ ('return (6,),'), {6,})) + assert (isequal (pycall_sympy__ ('return [],'), {})) +***** test + % dict + cmd = 'd = dict(); d["a"] = 6; d["b"] = 10; return d,'; + d = pycall_sympy__ (cmd); + assert (d.a == 6 && d.b == 10) +***** test + r = pycall_sympy__ ('return 6'); + assert (isequal (r, 6)) +***** test + r = pycall_sympy__ ('return "Hi"'); + assert (strcmp (r, 'Hi')) +***** test + % blank lines, lines with spaces + a = pycall_sympy__ ({ '', '', ' ', 'return 6', ' ', ''}); + assert (isequal (a, 6)) +***** test + % blank lines, strange comment lines + cmd = {'a = 1', '', '#', '', '# ', ' #', 'a = a + 2', ' #', 'return a'}; + a = pycall_sympy__ (cmd); + assert (isequal (a, 3)) +***** test + % return empty string (was https://bugs.python.org/issue25270) + assert (isempty (pycall_sympy__ ('return ""'))) +***** test + % return nothing (via an empty list) + % note distinct from 'return [],' + pycall_sympy__ ('return []') +***** test + % return nothing (because no return command) + pycall_sympy__ ('dummy = 1') +***** test + % return nothing (because no command) + pycall_sympy__ ('') +***** test + % return nothing (because no command) + pycall_sympy__ ({}) +***** error + % python exception while passing variables to python + % This tests the "INTERNAL_PYTHON_ERROR" path. + % FIXME: this is a very specialized test, relies on internal octsympy + % implementation details, and may need to be adjusted for changes. + disp('') + disp('**********************************************************************') + disp('') + disp(' Some deliberate AttributeError and ValueError may appear next') + disp('') + disp('v v v v v v v v v v v v v v v v v v v v v v v v') + b = sym([], 'S.This_is_supposed_to_make_an_exception', [1 1], 'Test', 'Test', 'Test'); + c = b + 1; + +********************************************************************** + + Some deliberate AttributeError and ValueError may appear next + +v v v v v v v v v v v v v v v v v v v v v v v v +Traceback (most recent call last): + File "", line 4, in + File "/usr/lib/python3/dist-packages/sympy/core/singleton.py", line 118, in __getattr__ + raise AttributeError( +AttributeError: Attribute 'This_is_supposed_to_make_an_exception' was not installed on SymPy registry S +***** test + % ...and after the above test, the pipe should still work + a = pycall_sympy__ ('return _ins[0]*2', 3); + assert (isequal (a, 6)) +***** test + % This command does not fail with native interface and '@pyobject' + s = warning ('off', 'OctSymPy:pythonic_no_convert'); + try + q = pycall_sympy__ ({'return type(int)'}); + catch + msg = lasterror.message; + assert (~ isempty (regexp (msg, '.*does not know how to.*'))) + end + warning (s) + disp('^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^') + disp(' End of deliberate errors!') + disp(' You should see "46/46" or "Passes 46 out of 46 tests" below') + disp('**********************************************************************') + % ...and after the above test, the pipe should still work + a = pycall_sympy__ ('return _ins[0]*2', 3); + assert (isequal (a, 6)) +Traceback (most recent call last): + File "", line 2, in + File "", line 12, in octoutput_drv + File "", line 96, in octoutput +ValueError: octoutput does not know how to export type +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + End of deliberate errors! + You should see "46/46" or "Passes 46 out of 46 tests" below +********************************************************************** +***** test + % complex input + [A, B] = pycall_sympy__ ('z = 2*_ins[0]; return (z.real,z.imag)', 3+4i); + assert (A, 6) + assert (B, 8) +***** test + % complex output + z = pycall_sympy__ ('return 3+2j'); + assert (z, 3+2i) +***** error + s = char ('abc', 'defgh', '12345'); + r = pycall_sympy__ ('return _ins[0]', s); +***** test + r = pycall_sympy__ ('return len(_ins[0])', ''); + assert (r == 0) +***** test + % ensure the 0x0 matrix in octave gets mapped to the empty list in python + % @sym/subsasgn currently replies on this behaviour + assert (pycall_sympy__ ('return _ins[0] == []', [])); +***** test + % ensure the empty string gets mapped to the empty string in python + assert (pycall_sympy__ ('return _ins[0] == ""', '')); +46 tests, 46 passed, 0 known failure, 0 skipped +[inst/assumptions.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/assumptions.m +***** test + syms x + assert(isempty(assumptions(x))) +***** test + x = sym('x', 'positive'); + a = assumptions(x); + assert(~isempty(strfind(a{1}, 'positive'))) +***** test + syms x + assert(isempty(assumptions(x))) +***** test + clear variables % for matlab test script + syms x positive + assert(~isempty(assumptions())) + clear x + assert(isempty(assumptions())) +***** test + % make sure we have at least these possible assumptions + A = {'real' 'positive' 'negative' 'integer' 'even' 'odd' 'rational'}; + B = assumptions('possible'); + assert (isempty (setdiff(A, B))) +***** test + A = assumptions('possible'); + for i = 1:length(A) + x = sym('x', A{i}); + a = assumptions(x); + assert(strcmp(a{1}, ['x: ' A{i}] )) + s1 = sympy (x); + s2 = ['Symbol(''x'', ' A{i} '=True)']; + assert (strcmp (s1, s2)) + end +***** test + syms x positive + syms y real + syms z + f = x*y*z; + a = assumptions(f); + assert(length(a) == 2) + assert(~isempty(strfind(a{1}, 'positive'))) + assert(~isempty(strfind(a{2}, 'real'))) +***** test + % dict output + syms x positive + syms y real + syms z + f = x*y*z; + [v, d] = assumptions(f, 'dict'); + assert(length(v) == 2) + assert(iscell(v)) + assert(isa(v{1}, 'sym')) + assert(isa(v{2}, 'sym')) + assert(length(d) == 2) + assert(iscell(d)) + assert(isstruct(d{1})) + assert(isstruct(d{2})) +***** test + %% assumptions on just the vars in an expression + clear variables % for matlab test script + syms x y positive + f = 2*x; + assert(length(assumptions(f))==1) + assert(length(assumptions())==2) +***** test + %% assumptions in cell/struct + clear variables % for matlab test script + syms x y z w positive + f = {2*x [1 2 y] {1, {z}}}; + assert(length(assumptions())==4) + assert(length(assumptions(f))==3) + clear x y z w + assert(length(assumptions())==3) + assert(length(assumptions(f))==3) +***** test + % multiple assumptions + n = sym('n', 'negative', 'even'); + assert (logical (n < 0)) + assert (~(logical (n > 0))) + assert (~(logical (n == -1))) +***** test + % multiple assumptions: eqn neither true nor false + n = sym('n', 'negative', 'even'); + assert (~isequal (n, sym(true)) && ~isequal (n, sym(false))) +***** test + %% TODO: rewrite later with https://github.com/gnu-octave/symbolic/issues/622 + a = pycall_sympy__ ('return Symbol("a", real=False)'); + assert (strcmp (assumptions (a), {'a: ~real'})) +13 tests, 13 passed, 0 known failure, 0 skipped +[inst/findsymbols.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/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/syms.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/syms.m +***** test + %% assumptions + syms x real + x2 = sym('x', 'real'); + assert (isequal (x, x2)) +***** test + % assumptions and clearing them on a symbol + syms x real + assert (~isempty (assumptions (x))) + syms x + assert (isempty (assumptions (x))) +***** test + % Note SMT would clear syms in existing expressions + syms x real + f = {x {2*x} cos(x/2)}; + assert (~isempty (assumptions (f))) + syms x + % but we do not: this would have to toggle for pure SMT compat + assert (~isempty (assumptions (f))) + % assert (isempty (assumptions (f))) +***** error + syms x clear +***** error + syms x positive y +***** error + % this sometimes catches typos or errors in assumption names + % (if you need careful checking, use sym not syms) + syms x positive evne +***** error + syms positive integer +***** test + % does not create a variable called positive + syms x positive integer + assert (logical(exist('x', 'var'))) + assert (~logical(exist('positive', 'var'))) +***** test + % Issue #885 + syms S(x) I(x) O(x) +***** test + % Issue #290 + syms FF(x) + syms ff(x) + syms Eq(x) +***** test + % Issue #290 + syms beta(x) +***** test + syms x real + syms f(x) + assert (~ isempty (assumptions (x))) +***** test + syms x real + f(x) = symfun(sym('f(x)'), x); + assert (~ isempty (assumptions (x))) + assert (~ isempty (assumptions (argnames (f)))) +13 tests, 13 passed, 0 known failure, 0 skipped +[inst/cell2sym.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/cell2sym.m +***** test + A = {1 2 3; 4 5 6}; + B = [1 2 3; 4 5 6]; + assert (isequal (cell2sym(A), sym(B))) +***** test + A = {'a' 'b'; 'c' 10}; + B = [sym('a') sym('b'); sym('c') sym(10)]; + assert (isequal (cell2sym(A), B)) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/digits.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/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/@logical/isAlways.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@logical/isAlways.m +***** error isAlways (true, false) +***** assert(isAlways(true)) +***** assert(~isAlways(false)) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/acoth.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/acoth.m +***** error acoth (sym(1), 2) +***** assert (isequaln (acoth (sym(nan)), sym(nan))) +***** shared x, d + d = 2; + x = sym('2'); +***** test + f1 = acoth(x); + f2 = acoth(d); + assert( abs(double(f1) - f2) < 1e-15 ) +***** test + D = [d d; d d]; + A = [x x; x x]; + f1 = acoth(A); + f2 = acoth(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip - syms n z - f = pochhammer (z, n); - h = function_handle (f, 'vars', [z n]); - A = h (1.1, 2.2); - B = pochhammer (1.1, 2.2); - assert (A, B) + y = sym('y'); + A = acoth (d); + f = acoth (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/cart2pol.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cart2pol.m +[inst/@sym/diff.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/diff.m +***** shared x,y,z + syms x y z ***** test - % multiple non-scalar inputs - x = sym ('x', [2 2]); - assume (x, 'real'); - y = sym ('y', [2 2]); - assume (y, 'real'); - [theta, r] = cart2pol (x, y); - assert (isequal (r, sqrt (x.^2 + y.^2))); - assert (isequal (tan (theta), y ./ x)); - % mixing scalar inputs with non-scalar inputs - syms z real - [theta_2, r_2, z_2] = cart2pol (x, y, z); - assert (isequal (r_2, sqrt (x.^2 + y.^2))); - assert (isequal (tan (theta_2), y ./ x)); - assert (isequal (z_2, z * ones (2, 2))); + % basic + assert(logical( diff(sin(x)) - cos(x) == 0 )) + assert(logical( diff(sin(x),x) - cos(x) == 0 )) + assert(logical( diff(sin(x),x,x) + sin(x) == 0 )) +***** test + % these fail when doubles are not converted to sym + assert(logical( diff(sin(x),x,2) + sin(x) == 0 )) + assert(logical( diff(sym(1),x) == 0 )) + assert(logical( diff(1,x) == 0 )) + assert(logical( diff(pi,x) == 0 )) +***** test + % symbolic diff of const (w/o variable) fails in sympy, but we work around + assert (isequal (diff(sym(1)), sym(0))) +***** test + % nth symbolic diff of const + assert (isequal (diff(sym(1), 2), sym(0))) + assert (isequal (diff(sym(1), sym(1)), sym(0))) +***** test + % octave's vector difference still works + assert(isempty(diff(1))) + assert((diff([2 6]) == 4)) +***** test + % other forms + f = sin(x); + g = diff(f,x,2); + assert (isequal (diff(f,2), g)) + assert (isequal (diff(f,sym(2)), g)) + g = diff(f,x); + assert (isequal (diff(f), g)) + assert (isequal (diff(f,1), g)) +***** test + % old SMT supported (still does?) the 'n' before the 'x' + % we might remove this someday, no longer seems documented in SMT + f = sin(x); + g = diff(f,x,2); + assert (isequal (diff(f,2,x), g)) + assert (isequal (diff(f,sym(2),x), g)) + g = diff(f,x); + assert (isequal (diff(f,1,x), g)) +***** test + % matrix + A = [x sin(x); x*y 10]; + B = [1 cos(x); y 0]; + assert(isequal(diff(A,x),B)) +***** test + % bug: use symvar + a = x*y; + b = diff(a); + assert (isequal (b, y)) +***** test + % bug: symvar should be used on the matrix, not comp-by-comp + a = [x y x*x]; + b = diff(a); + assert (~isequal (b(2), 1)) + assert (isequal (b, [1 0 2*x])) + b = diff(a,1); + assert (~isequal (b(2), 1)) + assert (isequal (b, [1 0 2*x])) +10 tests, 10 passed, 0 known failure, 0 skipped +[inst/@sym/norm.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/norm.m +***** assert (isequal (norm(sym(-6)), 6)) +***** test + % 2-norm default + A = [1 2; 3 4]; + n1 = norm (sym (A)); + assert (isequal (n1, sqrt (sqrt (sym(221)) + 15))) + assert (norm (A), double (n1), -eps) ***** test - % column vector with 2 entries syms x y real - [theta, r] = cart2pol ([x; y]); - assert (isequal (r, sqrt (x.^2 + y.^2))); - assert (isequal (tan (theta), y ./ x)); - % column vector with 3 entries - syms z real - [theta_2, r_2, z_2] = cart2pol ([x; y; z]); - assert (isequal (r_2, sqrt (x.^2 + y.^2))); - assert (isequal (tan (theta_2), y ./ x)); - assert (isequal (z_2, z)); + assert (isequal (norm([x 1; 3 y], 'fro'), sqrt(x^2 + y^2 + 10))) ***** test - % matrix with 2 columns - syms x y u v real - C = [x y; u v]; - [theta, r] = cart2pol (C); - assert (isequal (r, [sqrt(x.^2+y.^2); sqrt(u.^2+v.^2)])); - assert (isequal (tan (theta), [y/x; v/u])); - % matrix with 3 columns - syms z w real - C_2 = [x y z; u v w]; - [theta_2, r_2, z_2] = cart2pol (C_2); - assert (isequal (r, [sqrt(x.^2+y.^2); sqrt(u.^2+v.^2)])); - assert (isequal (tan (theta), [y/x; v/u])); - assert (isequal (z_2, [z; w])); -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/plus.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/plus.m + syms x real + assert (isequal (norm([x 1], 2), sqrt(x^2 + 1))) ***** test - % basic addition + % test sym vs double ord syms x - assert (isa (x+5, 'sym')) - assert (isa (5+x, 'sym')) - assert (isa (5+sym(4), 'sym')) - assert (isequal (5+sym(4), sym(9))) + assert (isequal (norm([x 2 1], 1), abs(x) + 3)) + assert (isequal (norm([x 2 1], sym(1)), abs(x) + 3)) + assert (isequal (norm([sym(-3) 2 1], inf), sym(3))) + assert (isequal (norm([sym(-3) 2 1], sym(inf)), sym(3))) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/dilog.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/dilog.m +***** assert (isequal (dilog (sym(1)), sym(0))) +***** assert (isequal (dilog (sym(0)), sym(pi)^2/6)) +***** assert (isequal (dilog (sym(2)), -sym(pi)^2/12)) +***** assert (double(dilog(sym(-1))), pi^2/4 - pi*1i*log(2), eps) ***** test - % array addition + % round-trip syms x - D = [0 1; 2 3]; - A = [sym(0) 1; sym(2) 3]; - DZ = D - D; - assert( isequal ( A + D , 2*D )) - assert( isequal ( D + A , 2*D )) - assert( isequal ( A + A , 2*D )) - assert( isequal ( A + 2 , D + 2 )) - assert( isequal ( 4 + A , 4 + D )) + f = dilog (x); + h = function_handle (f); + A = h (1.1); + B = dilog (1.1); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/repmat.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/repmat.m ***** test - % ensure MatrixExpr can be manipulated somewhat - syms n m integer - A = sym('A', [n m]); - B = subs(A, [n m], [5 6]); - B = B + 1; - assert (isa (B, 'sym')) - C = B(1, 1); % currently makes a MatrixElement - C = C + 1; - assert (isa (C, 'sym')) -3 tests, 3 passed, 0 known failure, 0 skipped + % simple + syms x + A = [x x x; x x x]; + assert (isequal (repmat(x, 2, 3), A)) +***** test + % block cf double + A = [1 2 3; 4 5 6]; + B = sym(A); + C = repmat(A, 2, 3); + D = repmat(B, 2, 3); + assert (isequal (C, D)) +***** test + % empty + A = repmat(sym([]), 2, 3); + assert (isempty(A)); + assert (isequal (size(A), [0 0])) +***** test + % more empties + A = repmat(sym(pi), [0 0]); + assert (isequal (size(A), [0 0])) + A = repmat(sym(pi), [0 3]); + assert (isequal (size(A), [0 3])) + A = repmat(sym(pi), [2 0]); + assert (isequal (size(A), [2 0])) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/rdivide.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/rdivide.m +***** test + % scalar + syms x + assert (isa (x ./ 1, 'sym')) + assert (isa (x ./ x, 'sym')) + assert (isequal (x ./ 1, x)) + assert (isequal (x ./ x, sym(1))) +***** test + % matrix-scalar + D = 2*[0 1; 2 3]; + A = sym(D); + assert (isequal ( A./2 , D/2 )) + assert (isequal ( A./sym(2) , D/2 )) + assert (isequal ( D./sym(2) , D/2 )) +***** test + % matrix ./ matrix + D = [1 2; 3 4]; + A = sym(D); + assert (isequal ( A./A , D./D )) + assert (isequal ( A./D , D./D )) + assert (isequal ( D./A , D./D )) +***** test + % matrix ./ matrix with symbols + syms x y + A = [x y; x^2 2*y]; + B = [y x; x y]; + assert (isequal ( A./A , sym(ones(2,2)) )) + assert (isequal ( A./B , [x/y y/x; x 2] )) +***** test + % scalar ./ matrix + D = [1 2; 3 4]; + A = sym(D); + assert (isequal ( 12./A , 12./D )) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/sum.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sum.m +***** error sum (sym(1), 2, 3) +***** error sum (sym(1), 42) +***** shared x,y,z + syms x y z +***** assert (isequal (sum (x), x)) +***** assert (isequal (sum ([x y z]), x+y+z)) +***** assert (isequal (sum ([x; y; z]), x+y+z)) +***** assert (isequal (sum ([x y z], 1), [x y z])) +***** assert (isequal (sum ([x y z], 2), x+y+z)) +***** shared a,b + b = [1 2; 3 4]; a = sym(b); +***** assert (isequal (sum(a), sum(b))) +***** assert (isequal (sum(a,1), sum(b,1))) +***** assert (isequal (sum(a,2), sum(b,2))) +***** test + % weird inputs + a = sum('xx', sym(1)); + assert (isequal (a, sym('xx'))) +11 tests, 11 passed, 0 known failure, 0 skipped +[inst/@sym/lgamma.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/lgamma.m +***** test + % tested by gammaln + assert (isequal (lgamma (sym ('x')), gammaln (sym ('x')))) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@sym/coshint.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/coshint.m +***** error coshint (sym(1), 2) +***** xtest + assert (isequaln (coshint (sym(nan)), sym(nan))) +!!!!! known failure +assert (isequaln (coshint (sym (nan)), sym (nan))) failed +***** shared x, d + d = 1; + x = sym('1'); +***** test + f1 = coshint(x); + f2 = 0.8378669409802082408947; + assert( abs(double(f1) - f2) < 1e-15 ) +***** test + D = [d d; d d]; + A = [x x; x x]; + f1 = coshint(A); + f2 = 0.8378669409802082408947; + f2 = [f2 f2; f2 f2]; + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) +***** test + % round trip + y = sym('y'); + A = coshint (d); + f = coshint (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 4 passed, 1 known failure, 0 skipped +[inst/@sym/isempty.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isempty.m +***** shared se, a + se = sym ([]); + a = sym ([1 2]); +***** assert (~isempty (sym (1))) +***** assert (isempty (sym (se))) +***** assert (isempty (se == [])) +***** test +***** test se(1) = 10; +***** test assert ( isa (se, 'sym')) +***** test assert ( isequal (se, 10)) +***** shared +***** test + % empty matrices + A = sym('A', [3 0]); + assert (isempty (A)) + A = sym(ones(3,0)); + assert (isempty (A)) +***** test + % non-empty symbolic-size matrices + syms n integer + A = sym('A', [3 n]); + assert (~isempty (A)) +***** xtest + % empty symbolic-size matrices + % FIXME: will fail until size stop lying by saying 1x1 + syms n integer + A = sym('A', [0 n]); + assert (isempty (A)) + A = sym('A', [n 0]); + assert (isempty (A)) +!!!!! known failure +assert (isempty (A)) failed +10 tests, 9 passed, 1 known failure, 0 skipped +[inst/@sym/acosh.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/acosh.m +***** error acosh (sym(1), 2) +***** assert (isequaln (acosh (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); +***** test + f1 = acosh(x); + f2 = acosh(d); + assert( abs(double(f1) - f2) < 1e-15 ) +***** test + D = [d d; d d]; + A = [x x; x x]; + f1 = acosh(A); + f2 = acosh(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) +***** test + % round trip + y = sym('y'); + A = acosh (d); + f = acosh (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped [inst/@sym/charpoly.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/charpoly.m ***** error charpoly (sym (1), 1, 2) @@ -3133,174 +4590,361 @@ B = sym([1 -2*x 0]); assert (isequal (charpoly(A), B)) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/euler.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/euler.m -***** error euler (sym(1), 2, 3) -***** assert (isequal (euler (sym(0)), sym(1))) +[inst/@sym/setxor.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/setxor.m ***** test - m = sym([0 1 2; 8 10 888889]); - A = euler (m); - B = sym([1 0 -1; 1385 -50521 0]); - assert (isequal (A, B)) + A = sym([1 2 3]); + B = sym([1 2 4]); + C = setxor(A, B); + D1 = sym([3 4]); + D2 = sym([4 3]); + assert (isequal (C, D1) || isequal (C, D2)) ***** test - syms x - assert (isequal (euler(6, x), x^6 - 3*x^5 + 5*x^3 - 3*x)) -***** assert (isnan (euler (3, sym(nan)))) + % one nonsym + A = sym([1 2 3]); + B = [1 2 4]; + C = setxor(A, B); + D1 = sym([3 4]); + D2 = sym([4 3]); + assert (isequal (C, D1) || isequal (C, D2)) ***** test - syms m x - em = euler (m, x); - A = subs(em, [m x], [2 sym(pi)]); - assert (isequal (A, sym(pi)^2 - sym(pi))) + % empty + A = sym([1 2 3]); + C = setxor(A, A); + assert (isempty (C)) ***** test - % vectorized - syms x y - A = euler([1; 2], [x; y]); - B = [x - sym(1)/2; y^2 - y]; - assert (isequal (A, B)) + % empty input + A = sym([1 2]); + C = setxor(A, []); + assert (isequal (C, A) || isequal (C, sym([2 1]))) ***** test - % round trip - syms m z - f = euler (m, z); - h = function_handle (f, 'vars', [m z]); - A = h (2, 2.2); - B = euler (2, 2.2); - assert (A, B) + % scalar + syms x + assert (isequal (setxor([x 1], x), sym(1))) + assert (isempty (setxor(x, x))) ***** test - % compare vpa to maple: Digits:=34; evalf(euler(13, exp(1)+Pi*I/13)); - A = vpa('1623.14184180556920918624604530515') + ... - vpa('4270.98066989140286451493108809574')*1i; - z = vpa (exp(1), 32) + vpa(pi, 32)/13*1i; - B = euler (13, z); - relerr = abs(double(abs((B - A)/A))); - assert (relerr < 20*eps); -***** xtest - % as above, high-prec result broken in 1.12: https://github.com/sympy/sympy/issues/24156 - A = vpa('1623.14184180556920918624604530515') + ... - vpa('4270.98066989140286451493108809574')*1i; - z = vpa (exp(1), 32) + vpa(pi, 32)/13*1i; - B = euler (13, z); - relerr = abs(double(abs((B - A)/A))); - assert (relerr < 2e-31); -!!!!! known failure -assert (relerr < 2e-31) failed -10 tests, 9 passed, 1 known failure, 0 skipped -[inst/@sym/isscalar.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isscalar.m -***** assert(isscalar(sym('x'))) + A = interval(sym(1), 3); + B = interval(sym(2), 5); + C = setxor(A, B); + D = union (interval (sym(1), 2, false, true), interval (sym(3), 5, true, false)); + assert( isequal( C, D)) +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@sym/frac.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/frac.m ***** test - a = sym([1 2 3]); - assert(~isscalar(a)) -***** assert(~isscalar(sym([]))) + f1 = frac(sym(11)/10); + f2 = sym(1)/10; + assert (isequal (f1, f2)) +***** test + d = sym(-11)/10; + c = sym(9)/10; + assert (isequal (frac (d), c)) +***** test + d = sym(-19)/10; + c = sym(1)/10; + assert (isequal (frac (d), c)) 3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/pinv.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/pinv.m +[inst/@sym/symsum.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/symsum.m +***** error symsum (sym(1), 2, 3, 4, 5) ***** test - % scalar + % finite sums + syms n + assert (isequal (symsum(n,n,1,10), 55)) + assert(isa(symsum(n,n,1,10), 'sym')) + assert (isequal (symsum(n,n,sym(1),sym(10)), 55)) + assert (isequal (symsum(n,n,sym(1),sym(10)), 55)) + assert (isequal (symsum(1/n,n,1,10), sym(7381)/2520)) +***** test + % negative limits + syms n + assert (isequal (symsum(n,n,-3,3), sym(0))) + assert (isequal (symsum(n,n,-3,0), sym(-6))) + assert (isequal (symsum(n,n,-3,-1), sym(-6))) +***** test + % one input + syms n + f = symsum (n); + g = n^2/2 - n/2; + assert (isequal (f, g)) + f = symsum (2*n); + g = n^2 - n; + assert (isequal (f, g)) +***** test + % constant input + f = symsum (sym(2)); syms x - assert (isequal (pinv(x), 1/x)) + g = 2*x; + assert (isequal (f, g)) ***** test - % 2x3 - A = [1 2 3; 4 5 6]; - assert (max (max (abs (double (pinv (sym (A))) - pinv(A)))) <= 10*eps) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/isnan.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isnan.m -***** shared x,zoo,oo,snan - oo = sym(inf); + % two inputs + syms n + f = symsum (2*n, n); + g = n^2 - n; + assert (isequal (f, g)) +***** test + % two inputs, second is range + syms n + f = symsum (n, [1 6]); + g = 21; + assert (isequal (f, g)) + f = symsum (n, [sym(1) 6]); + g = 21; + assert (isequal (f, g)) + f = symsum (2*n, [1 6]); + g = 2*21; + assert (isequal (f, g)) +***** test + % three inputs, last is range + syms n + f = symsum (2*n, n, [1 4]); + g = sym(20); + assert (isequal (f, g)) + f = symsum (2*n, n, [sym(1) 4]); + g = sym(20); + assert (isequal (f, g)) + f = symsum (2, n, [sym(1) 4]); + g = sym(8); + assert (isequal (f, g)) +***** test + % three inputs, no range + syms n + f = symsum (2*n, 1, 4); + g = sym(20); + assert (isequal (f, g)) + f = symsum (5, sym(1), 3); + g = sym(15); + assert (isequal (f, g)) +***** test + % ok to use double's for arguments in infinite series + syms n oo + assert(isequal(symsum(1/n^2,n,1,oo), sym(pi)^2/6)) + assert(isequal(symsum(1/n^2,n,1,inf), sym(pi)^2/6)) +***** test + % should be oo because 1 is real but seems to be + % zoo/oo depending on sympy version + syms n oo zoo = sym('zoo'); - x = sym('x'); - snan = sym(nan); + assert (isequal (symsum(1/n,n,1,oo), oo) || ... + isequal (symsum(1/n,n,1,oo), zoo)) +11 tests, 11 passed, 0 known failure, 0 skipped +[inst/@sym/sinc.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sinc.m +***** error sinc (sym(1), 2) +***** assert (isequaln (sinc (sym(nan)), sym(nan))) +***** assert (isequal (sinc (sym(0)), sym(1))) +***** assert (isequal (sinc (sym(1)), sym(0))) +***** assert (isequal (sinc (-sym(1)), sym(0))) +***** assert (double (sinc (sym(pi))), sinc (pi), -10*eps) ***** test - % various ops that give nan - assert (isnan(0*oo)) - assert (isnan(0*zoo)) - assert (isnan(snan)) - assert (isnan(snan-snan)) - assert (isnan(oo+snan)) - assert (isnan(oo-oo)) - assert (isnan(oo-zoo)) - assert (isnan(oo+zoo)) - assert (~isnan(oo)) - assert (~isnan(zoo)) - assert (~isnan(oo+oo)) + A = [-sym(1)/2 sym(1)/2 pi; -sym(7)/2 sym(71)/2 sym(101)/3]; + D = double (A); + assert (sinc (D), double (sinc (A)), -200*eps) ***** test - % more ops give nan - assert(isnan(x+snan)) - assert(isnan(x*snan)) - assert(isnan(0*snan)) - assert(isnan(x+nan)) - assert(isnan(x*nan)) - assert(isnan(sym(0)*nan)) + A = [sym(51)/2 sym(1001)/3 sym(10001)/3 sym(100001)/3]; + D = double (A); + assert (sinc (D), double (sinc (A)), 1e-10) ***** test - % array - assert (isequal( isnan([oo zoo]), [0 0] )) - assert (isequal( isnan([10 snan]), [0 1] )) - assert (isequal( isnan([snan snan]), [1 1] )) - assert (isequal( isnan([snan x]), [1 0] )) + % round trip + syms x + A = sinc (1); + f = sinc (x); + h = function_handle (f); + B = h (1); + assert (A, B, -eps) ***** test - % sub in to algebraic expression gives nan - y = x - oo; - y = subs(y, x, oo); - assert(isnan(y)) + % round trip + syms x + f = sinc (x); + h = function_handle (f); + A = sinc (1.5); + B = h (1.5); + assert (A, B, -eps) ***** test - % Must not contain string 'symbol'; these all should make an - % actual nan. Actually a ctor test, not isnan. - y = sym(nan); - assert (isempty (strfind (sympy (y), 'Symbol'))) - y = sym('nan'); - assert (isempty (strfind (sympy (y), 'Symbol'))) - y = sym('NaN'); - assert (isempty( strfind (sympy (y), 'Symbol'))) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/isallconstant.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isallconstant.m -***** assert (isallconstant([sym(1) 2 3])) + syms x + h = function_handle (sinc (x)); + A = double (sinc (sym (12)/10)); + B = h (1.2); + C = sinc (1.2); + assert (A, B, -eps) + assert (A, C, -eps) +11 tests, 11 passed, 0 known failure, 0 skipped +[inst/@sym/kroneckerDelta.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/kroneckerDelta.m +***** error kroneckerDelta (sym(1), 2, 3) ***** test syms x - assert (~isallconstant([sym(1) x 3])) + assert (isequal (kroneckerDelta (x, x), sym(1))) +***** assert (isequal (kroneckerDelta ([sym(1) 2 3], [1 2 0]), sym([1 1 0]))) +***** test + % round trip + syms x y + f = kroneckerDelta (x, y); + h = function_handle (f); + assert (h (1, 2), 0) + assert (h (2, 2), 1) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/isAlways.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isAlways.m ***** test + % basics + assert(isAlways(true)) + assert(isAlways(1==1)) + assert(isAlways(sym(1)==sym(1))) + assert(isAlways(sym(1)==1)) +***** test + % numbers to logic? + assert (isAlways(sym(1))) + assert (isAlways(sym(-1))) + assert (~isAlways(sym(0))) +***** shared x syms x - assert (~isallconstant([sym(1) x; sym(2) 3])) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/times.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/times.m ***** test - % scalar + % in this case it is boolean + expr = x - x == 0; + assert (logical(expr)) + assert (isAlways(expr)) + % and both are logical type + assert (islogical(logical(expr))) + assert (islogical(isAlways(expr))) +***** test + % structurally same and mathematically true + % (here expr should be sym, non-boolean) + expr = x == x; + assert (logical(expr)) + assert (isAlways(expr)) + %assert (~islogical(expr)) % FIXME: Issue #56 + %assert (isa(expr, 'sym)) +***** test + % structurally same and mathematically true + % (here expr should be sym, non-boolean) + expr = 1 + x == x + 1; + assert (logical(expr)) + assert (isAlways(expr)) +***** test + % non-zero numbers are true + assert (isAlways(sym(1))) + assert (isAlways(sym(-10))) + assert (~isAlways(sym(0))) +***** shared x, y + syms x y +***** test + % structurally same and mathematically true + % (here expr should be sym, non-boolean) + expr = x*(1+y) == x*(y+1); + assert (logical(expr)) + assert (isAlways(expr)) + assert (islogical(isAlways(expr))) +***** test + % Now for some differences + % simplest example from SymPy FAQ + expr = x*(1+y) == x+x*y; + assert (~logical(expr)) + assert (isAlways(expr)) +***** test + % more differences 1, these don't simplify in sympy (as of 2016-01) + expr = (x+1)^2 == x*x + 2*x + 1; + assert (~logical(expr)) + assert (isAlways(expr)) +***** test + % more differences 2 + expr = sin(2*x) == 2*sin(x)*cos(x); + assert (~logical(expr)) + assert (isAlways(expr)) +***** test + % more differences 3, false + expr = x*(x+y) == x^2 + x*y + 1; + assert (~logical(expr)) + assert (~isAlways(expr)) + assert (~isAlways(expr, 'unknown', 'error')) +***** test + % logically not equal, math equal + exprn = x*(x+y) ~= x^2 + x*y; + assert (logical(exprn)) + assert (~isAlways(exprn)) +***** test + % logically not equal, math not equal + exprn = x*(x+y) ~= x^2 + x*y + 1; + assert (logical(exprn)) + assert (isAlways(exprn)) +***** test + % equal and not equal + e1 = sin(x)^2 + cos(x)^2 == 1; + e2 = sin(x)^2 + cos(x)^2 == 2; + assert (~logical(e1)) + assert (isAlways(e1)) + assert (~logical(e2)) + assert (~isAlways(e2)) + assert (~isAlways(e2, 'unknown', 'error')) +***** error isAlways(x, 'unknown', 'kevin') +***** error isAlways(x, 'unknown') +***** error isAlways(x, 'kevin', 'true') +***** error + a = [x*(x+y)==x^2+x*y x==y]; + b = isAlways(a, 'unknown', 'error'); +***** error + a = x==y; + b = isAlways(a, 'unknown', 'error'); +***** test + % array, unknown keyword + a = [x==x x==x+1 x==y x*(x+y)==x^2+x*y cos(x)^2+sin(x)^2==2]; + b = isAlways(a, 'unknown', false); + c = isAlways(a, 'unknown', 'false'); + expect = [true false false true false]; + assert (islogical(b)) + assert (isequal (b, expect)) + assert (isequal (c, expect)) + b = isAlways(a, 'unknown', true); + c = isAlways(a, 'unknown', 'true'); + expect = [true false true true false]; + assert (islogical(b)) + assert (isequal (b, expect)) + assert (isequal (c, expect)) +***** test + % ineq + e = x*(x+y) <= x^2 + x*y + 1; + assert (~logical(e)) + assert (isAlways(e)) + e = x*(x+y) <= x^2 + x*y; + assert (~logical(e)) + assert (isAlways(e)) +21 tests, 21 passed, 0 known failure, 0 skipped +[inst/@sym/conj.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/conj.m +***** test + a = sym(6); + b = sym(5i); + assert (isequal (conj(a), a)) + assert (isequal (conj(b), -b)) + assert (isequal (conj(a+b), a-b)) +***** test syms x - assert (isa (x.*2, 'sym')) - assert (isequal (x.*2, x*2)) - assert (isequal (2.*sym(3), sym(6))) - assert (isequal (sym(2).*3, sym(6))) + assert (isequal (conj(conj(x)), x)) ***** test - % matrix-matrix and matrix-scalar - D = [0 1; 2 3]; - A = sym(D); - assert (isequal ( 2.*A , 2*D )) - assert (isequal ( A.*2 , 2*D )) - assert (isequal ( A.*A , D.*D )) - assert (isequal ( A.*D , D.*D )) - assert (isequal ( D.*A , D.*D )) + syms x real + assert (isequal (conj(x), x)) ***** test + % array syms x - A = [1 x]; - B = [2 3]; - assert (isequal (A.*B, [2 3*x])) + A = [x 6+1i; sym(1) x+2i]; + B = [conj(x) 6-1i; sym(1) conj(x)-2i]; + assert (isequal (conj(A), B)) ***** test - % immutable test - A = sym([1 2]); - B = sym('ImmutableDenseMatrix([[Integer(1), Integer(2)]])'); - assert (isequal (A.*A, B.*B)) + % true/false + t = sym(true); + f = sym(false); + assert (isequal ( conj(t), t)) + assert (isequal ( conj(f), f)) ***** test - % MatrixSymbol test - A = sym([1 2; 3 4]); - B = sym('ImmutableDenseMatrix([[Integer(1), Integer(2)], [Integer(3), Integer(4)]])'); - C = sym('MatrixSymbol("C", 2, 2)'); - assert (~ isempty (strfind (sympy (C.*C), 'Hadamard'))) - assert (~ isempty (strfind (sympy (A.*C), 'Hadamard'))) - assert (~ isempty (strfind (sympy (C.*A), 'Hadamard'))) - assert (~ isempty (strfind (sympy (B.*C), 'Hadamard'))) - assert (~ isempty (strfind (sympy (C.*B), 'Hadamard'))) -5 tests, 5 passed, 0 known failure, 0 skipped + % round trip + syms x + d = 3 - 5i; + f = conj (x); + A = conj (d); + h = function_handle (f); + B = h (d); + assert (A, B) +6 tests, 6 passed, 0 known failure, 0 skipped [inst/@sym/eig.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/eig.m ***** test @@ -3325,19 +4969,6 @@ assert (isequal (size (e), [3 1])) assert (sum(logical(e == 6)) == 2) assert (sum(logical(e == 7)) == 1) -:22: SymPyDeprecationWarning: - -non-Expr objects in a Matrix is deprecated. Matrix represents -a mathematical matrix. To represent a container of non-numeric -entities, Use a list of lists, TableForm, NumPy array, or some -other data structure instead. - -See https://docs.sympy.org/latest/explanation/active-deprecations.html#deprecated-non-expr-in-matrix -for details. - -This has been deprecated since SymPy version 1.9. It -will be removed in a future version of SymPy. - ***** test % matrix with symbols syms x y positive @@ -3364,459 +4995,1546 @@ assert (sum(logical(V(3,:) ~= 0)) == 1) assert (sum(logical(V(4,:) ~= 0)) == 1) 6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@sym/hessian.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/hessian.m -***** error hessian (sym(1), 2, 3) -***** error hessian ([sym(1) sym(2)]) -***** shared x,y,z - syms x y z +[inst/@sym/ellipticPi.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipticPi.m +***** error ellipticPi (sym (1)) +***** error ellipticPi (sym (1), 2, 3, 4) +***** assert (double (ellipticPi (sym (-23)/10, sym (pi)/4, 0)), 0.5876852228, 10e-11) +***** assert (double (ellipticPi (sym (1)/3, sym (pi)/3, sym (1)/2)), 1.285032276, 10e-11) +***** assert (double (ellipticPi (sym (2), sym (pi)/6, sym (2))), 0.7507322117, 10e-11) +***** xtest + % FIXME: search/report upstream + assert (double (ellipticPi (sym (-1), 0, sym (1))), 0) +!!!!! known failure +ASSERT errors for: assert (double (ellipticPi (sym (-1), 0, sym (1))),0) + + Location | Observed | Expected | Reason + () NaN 0 'NaN' mismatch +***** xtest + % FIXME: this is a regression somewhere: loss of precision: Issue #1064 + % compare to Maple, complete + us = vpa (ellipticPi (sym(1)/6, sym(4)/3), 40); + % > evalf(EllipticPi(sin(1/6), sqrt(4/3)), 40); + maple = vpa ('2.019271696236161760696477679310987869058', 40) - ... + vpa ('1.708165765120289929280805062355360570830j', 40); + assert (abs (double (maple - us)), 0, 2e-39) +!!!!! known failure +ASSERT errors for: assert (abs (double (maple - us)),0,2e-39) + + Location | Observed | Expected | Reason + () 5.7666e-32 0 Abs err 5.7666e-32 exceeds tol 2e-39 by 6e-32 ***** test - % 1D - f = x^2; - assert (isequal (hessian(f), diff(f,x,x))) - assert (isequal (hessian(f,{x}), diff(f,x,x))) - assert (isequal (hessian(f,x), diff(f,x,x))) + % compare to Maple, complete + us = vpa (ellipticPi (sym(1)/6, sym(4)/3), 40); + % > evalf(EllipticPi(sin(1/6), sqrt(4/3)), 40); + maple = vpa ('2.019271696236161760696477679310987869058', 40) - ... + vpa ('1.708165765120289929280805062355360570830j', 40); + assert (abs (double (maple - us)), 0, 2e-30) ***** test - % const - f = sym(1); - g = sym(0); - assert (isequal (hessian(f), g)) - assert (isequal (hessian(f,x), g)) + % compare to Maple, incomplete + us = vpa (ellipticPi (sym(8)/7, sym(4)/3, sym(2)/7), 40); + % > evalf(EllipticPi(sin(4/3), 8/7, sqrt(2/7)), 40); + maple = vpa ('2.089415796799294830305265090302275542033', 40) - ... + vpa ('4.798862045930802761256228043192491271947j', 40); + assert (abs (double (maple - us)), 0, 6e-39) +9 tests, 7 passed, 2 known failures, 0 skipped +[inst/@sym/coth.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/coth.m +***** error coth (sym(1), 2) +***** assert (isequaln (coth (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); ***** test - % double const - f = 1; - g = sym(0); - assert (isequal (hessian(f,x), g)) + f1 = coth(x); + f2 = coth(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - % linear - f = 42*x; - g = sym(0); - assert (isequal (hessian(f), g)) - assert (isequal (hessian(f,x), g)) + D = [d d; d d]; + A = [x x; x x]; + f1 = coth(A); + f2 = coth(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test - % linear - f = 42*x - sym('a')*y; - g = [0 0; 0 0]; - assert (isequal (hessian(f, {x y}), g)) + % round trip + y = sym('y'); + A = coth (d); + f = coth (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/symvar.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/symvar.m +***** error symvar (sym(1), 2, 3) ***** test - % 2d - f = x*cos(y); - g = [0 -sin(y); -sin(y) -f]; - assert (isequal (hessian(f), g)) - assert (isequal (hessian(f, {x y}), g)) + %% some empty cases + assert (isempty (symvar (sym(1)))); + assert (isempty (symvar (sym(1),1))); + assert (isempty (symvar (sym(1),0))); + assert (isempty (symvar (sym('x'),0))); +***** shared x,y,f + x=sym('x'); y=sym('y'); f=x^2+3*x*y-y^2; +***** assert (isequal (symvar (f), [x y])); +***** assert (isequal (symvar (f, 1), x)); ***** test - % 3d - f = x*cos(z); - Hexp = [0 0 -sin(z); sym(0) 0 0; -sin(z) 0 -f]; - H = hessian(f, {x y z}); - assert (isequal (H, Hexp)) -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/dot.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/dot.m -***** error dot (sym(1), 2, 3) + %% closest to x + syms x y a b c xx + alpha = sym('alpha'); + % https://www.mathworks.com/matlabcentral/newsreader/view_thread/237730 + assert( isequal (symvar (b*xx*exp(alpha) + c*sin(a*y), 2), [xx y])) + %% tests to match Matlab R2013b +***** shared x,y,z,a,b,c,X,Y,Z + syms x y z a b c X Y Z ***** test - a = sym([1; 1; 0]); - b = sym([1; 2; 4]); - c = dot(a, b); - assert (isequal (c, sym(3))) + %% X,Y,Z first if no 2nd argument + s = prod([x y z a b c X Y Z]); + assert (isequal( symvar (s), [X Y Z a b c x y z] )) ***** test - syms x - a = sym([x; 0; 0]); - b = sym([0; 1; 0]); - c = dot(a, b); - assert (isequal (c, sym(0))) + %% uppercase have *low* priority with argument? + s = prod([x y z a b c X Y Z]); + assert (isequal (symvar (s,4), [x, y, z, c] )) ***** test - assert (isequal (dot (sym([1 i]), sym([i 2])), sym(-i))) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/qr.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/qr.m -***** error qr (sym(1), 2, 3) -***** error [Q, R, P] = qr (sym(1)) -***** error qr (sym(1), 1) + %% closest to x + s = prod([y z a b c Y Z]); + assert (isequal( symvar (s,6), [ y, z, c, b, a, Y] )) + s = prod([a b c Y Z]); + assert (isequal( symvar (s,4), [ c, b, a, Y] )) ***** test - % scalar - [q, r] = qr(sym(6)); - assert (isequal (q, sym(1))) - assert (isequal (r, sym(6))) + %% upper case letters in correct order + s = X*Y*Z; + assert (isequal( symvar (s,3), [X Y Z] )) ***** test - syms x positive - [q, r] = qr(x); - assert (isequal (q*r, x)) - assert (isequal (q, sym(1))) - assert (isequal (r, x)) + % diff. assumptions make diff. symbols + x1 = sym('x'); + x2 = sym('x', 'positive'); + f = x1*x2; + assert (length (symvar (f)) == 2) + z = symvar (f, 1); + assert (xor (isequal (z, x1), isequal (z, x2))) +10 tests, 10 passed, 0 known failure, 0 skipped +[inst/@sym/bernoulli.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/bernoulli.m +***** error bernoulli (sym(1), 2, 3) +***** assert (isequal (bernoulli (sym(8)), -sym(1)/30)) +***** assert (isequal (bernoulli (sym(9)), sym(0))) +***** test syms x + assert (isequal (bernoulli(3,x), x^3 - 3*x^2/2 + x/2)) ***** test - % trickier if x could be zero, fails on 1.8 <= SymPy <= 1.10.1 - syms x - [q, r] = qr(x); - if (pycall_sympy__ ('return Version(spver) > Version("1.10.1")')) - assert (isequal (q*r, x)) + % two different definitions in literature + assert (isequal (abs (bernoulli (sym(1))), sym(1)/2)) +***** test + % we use B_1 = 1/2 + if (pycall_sympy__ ('return Version(spver) >= Version("1.12.dev")')) + assert (isequal (bernoulli (sym(1)), sym(1)/2)) end ***** test - A = [1 2; 3 4]; - B = sym(A); - [Q, R] = qr(B); - assert (isequal (Q*R, B)) - assert (isequal (R(2,1), sym(0))) - assert (isequal (Q(:,1)'*Q(:,2), sym(0))) - %[QA, RA] = qr(A) - %assert ( max(max(double(Q)-QA)) <= 10*eps) - %assert ( max(max(double(Q)-QA)) <= 10*eps) + m = sym([0 2; 8 888889]); + A = bernoulli (m); + B = [1 sym(1)/6; -sym(1)/30 0]; + assert (isequal (A, B)) ***** test - % non square: tall skinny - A = sym([1 2; 3 4; 5 6]); - [Q, R] = qr (A, 0); - assert (size (Q), [3 2]) - assert (size (R), [2 2]) - assert (isequal (Q*R, A)) + syms x + A = bernoulli ([0; 1], x); + B = [sym(1); x - sym(1)/2]; + assert (isequal (A, B)) ***** test - % non square: short fat - A = sym([1 2 3; 4 5 6]); - [Q, R] = qr (A); - assert (isequal (Q*R, A)) + % round trip + syms n x + f = bernoulli (n, x); + h = function_handle (f, 'vars', [n x]); + A = h (2, 2.2); + B = bernoulli (2, 2.2); + assert (A, B) +9 tests, 9 passed, 0 known failure, 0 skipped +[inst/@sym/assumeAlso.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/assumeAlso.m ***** test - % non square: short fat, rank deficient - A = sym([1 2 3; 2 4 6]); - [Q, R] = qr (A); - assert (isequal (Q*R, A)) - A = sym([1 2 3; 2 4 6; 0 0 0]); - [Q, R] = qr (A); - assert (isequal (Q*R, A)) + syms x + x = assumeAlso(x, 'positive'); + a = assumptions(x); + assert(strcmp(a, 'x: positive')) +***** error + syms x + x = assumeAlso (x, x); ***** test - % rank deficient - A = sym([1 2 3; 2 4 6; 0 0 0]); - [Q, R] = qr (A); - assert (isequal (Q*R, A)) - A = sym([1 2 3; 2 5 6; 0 0 0]); - [Q, R] = qr (A); - assert (isequal (Q*R, A)) + syms x positive + x = assumeAlso(x, 'integer'); + [tilde, a] = assumptions(x, 'dict'); + assert(a{1}.integer) + assert(a{1}.positive) ***** test - % single return value R not Q - assert (isequal (qr (sym(4)), sym(4))) -12 tests, 12 passed, 0 known failure, 0 skipped -[inst/@sym/function_handle.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/function_handle.m -***** shared x,y,z - syms x y z + % multiple assumptions + syms x positive + x = assumeAlso(x, 'integer', 'even'); + [tilde, a] = assumptions(x, 'dict'); + assert(a{1}.integer) + assert(a{1}.positive) + assert(a{1}.even) ***** test - % basic test - h = function_handle(2*x); - assert(isa(h, 'function_handle')) - assert(h(3)==6) + % multiple assumptions + syms x integer + x = assumeAlso (x, 'even', 'positive'); + [tilde, a] = assumptions (x, 'dict'); + assert (a{1}.integer) + assert (a{1}.even) + assert (a{1}.positive) +***** test + % has output so avoids workspace + syms x positive + x2 = x; + f = sin(x); + assumeAlso(x, 'integer'); + a = assumptions(x); + assert(strcmp(a, 'x: positive, integer') || strcmp(a, 'x: integer, positive')) + a = assumptions(x2); + assert(strcmp(a, 'x: positive, integer') || strcmp(a, 'x: integer, positive')) + a = assumptions(f); + assert(strcmp(a, 'x: positive, integer') || strcmp(a, 'x: integer, positive')) +***** test + % has no output so does workspace + syms x positive + x2 = x; + f = sin(x); + assumeAlso(x, 'integer'); + a = assumptions(x); + assert(strcmp(a, 'x: positive, integer') || strcmp(a, 'x: integer, positive')) + a = assumptions(x2); + assert(strcmp(a, 'x: positive, integer') || strcmp(a, 'x: integer, positive')) + a = assumptions(f); + assert(strcmp(a, 'x: positive, integer') || strcmp(a, 'x: integer, positive')) +***** error + syms a + assumeAlso (a > 0) +***** test + syms x y + assumeAlso ([x y], 'even') + assert (strcmp (assumptions (x), 'x: even')) + assert (strcmp (assumptions (y), 'y: even')) +***** test + syms x y positive + f = sin (2*x); + assumeAlso ([x y], 'even') + assert (strcmp (assumptions (x), 'x: even, positive') || strcmp (assumptions (x), 'x: positive, even')) + assert (strcmp (assumptions (y), 'y: even, positive') || strcmp (assumptions (y), 'y: positive, even')) + assert (strcmp (assumptions (f), 'x: even, positive') || strcmp (assumptions (f), 'x: positive, even')) +***** test + % with output, original x and y are unchanged + syms x y positive + f = sin (2*x); + [p, q] = assumeAlso ([x y], 'even'); + assert (strcmp (assumptions (x), 'x: positive')) + assert (strcmp (assumptions (y), 'y: positive')) + assert (strcmp (assumptions (f), 'x: positive')) + assert (strcmp (assumptions (p), 'x: even, positive') || strcmp (assumptions (p), 'x: positive, even')) + assert (strcmp (assumptions (q), 'y: even, positive') || strcmp (assumptions (q), 'y: positive, even')) +11 tests, 11 passed, 0 known failure, 0 skipped +[inst/@sym/matlabFunction.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/matlabFunction.m ***** test % autodetect inputs - h = function_handle(2*x*y, x+y); + syms x y + s = warning('off', 'OctSymPy:function_handle:nocodegen'); + h = matlabFunction(2*x*y, x+y); + warning(s) [t1, t2] = h(3,5); assert(t1 == 30 && t2 == 8) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@sym/findsym.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/findsym.m +***** assert (strcmp (findsym (sym(2)), '')); +***** shared x,y,f + x=sym('x'); y=sym('y'); f=x^2+3*x*y-y^2; +***** assert (strcmp (findsym (f), 'x,y')); +***** assert (strcmp (findsym (f,1), 'x')); ***** test - % specified inputs - h = function_handle(2*x*y, 'vars', [x y]); - assert(h(3,5)==30) - h = function_handle(2*x*y, x+y, 'vars', [x y]); - [t1, t2] = h(3,5); - assert(t1 == 30 && t2 == 8) + % test order of returned vars + syms x y a b c xx + % https://www.mathworks.com/matlabcentral/newsreader/view_thread/237730 + alpha = sym('alpha'); + assert (strcmp (findsym(b*xx*exp(alpha) + c*sin(a*y), 2), 'xx,y')) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/floor.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/floor.m +***** error floor (sym(1), 2) +***** assert (isequaln (floor (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); ***** test - % cell arrays for vars list - h = function_handle(2*x*y, x+y, 'vars', {x y}); - [t1, t2] = h(3,5); - assert(t1 == 30 && t2 == 8) - h = function_handle(2*x*y, x+y, 'vars', {'x' 'y'}); - [t1, t2] = h(3,5); - assert(t1 == 30 && t2 == 8) + f1 = floor(x); + f2 = floor(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - % cell arrays specify order, overriding symvar order - h = function_handle(x*y, 12/y, 'vars', {y x}); - [t1, t2] = h(3, 6); - assert(t1 == 18 && t2 == 4) - h = function_handle(x*y, 12/y, 'vars', [y x]); - [t1, t2] = h(3, 6); - assert(t1 == 18 && t2 == 4) + D = [d d; d d]; + A = [x x; x x]; + f1 = floor(A); + f2 = floor(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test - % cell arrays specify order, overriding symvar order - h = function_handle(x*y, 12/y, 'vars', {y x}); - [t1, t2] = h(3, 6); - assert(t1 == 18 && t2 == 4) - h = function_handle(x*y, 12/y, 'vars', [y x]); - [t1, t2] = h(3, 6); - assert(t1 == 18 && t2 == 4) + % round trip + y = sym('y'); + A = floor (d); + f = floor (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/horzcat.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/horzcat.m ***** test - % Functions with different names in Sympy. - f = abs(x); % becomes Abs(x) - h = function_handle(f); - assert(h(-10) == 10) - f = ceil(x); - h = function_handle(f); - assert(h(10.1) == 11) + % basic + syms x + A = [x x]; + B = horzcat(x, x); + C = horzcat(x, x, x); + assert (isa (A, 'sym')) + assert (isa (B, 'sym')) + assert (isa (C, 'sym')) + assert (isequal (size(A), [1 2])) + assert (isequal (size(B), [1 2])) + assert (isequal (size(C), [1 3])) ***** test - % 'file' with empty filename returns handle - h = function_handle(2*x*y, 'file', ''); - assert(isa(h, 'function_handle')) - assert(h(3,5)==30) - h = function_handle(2*x*y, 'vars', {x y}, 'file', ''); - assert(isa(h, 'function_handle')) - assert(h(3,5)==30) + % basic, part 2 + syms x + A = [x 1]; + B = [1 x]; + C = [1 2 x]; + assert (isa (A, 'sym')) + assert (isa (B, 'sym')) + assert (isa (C, 'sym')) + assert (isequal (size(A), [1 2])) + assert (isequal (size(B), [1 2])) + assert (isequal (size(C), [1 3])) ***** test - % output to disk - fprintf('\n') - if (exist ('OCTAVE_VERSION', 'builtin')) - temp_file = tempname('', 'oct_'); - else - temp_file = tempname(); - end - % allow loading function from temp_file - [temp_path, ans, ans] = fileparts(temp_file); - addpath(temp_path); - f = function_handle(2*x*y, 2^x, 'vars', {x y z}, 'file', temp_file); - assert( isa(f, 'function_handle')) - addpath(temp_path); % Matlab 2014a needs this? - [a,b] = f(10,20,30); - assert (isnumeric (a) && isnumeric (b)) - assert (a == 400) - assert (b == 1024) - if (exist ('OCTAVE_VERSION', 'builtin')) - assert (unlink([temp_file '.m']) == 0) - else - delete ([temp_file '.m']) - end - % remove temp_path from load path - rmpath(temp_path); - -Wrote file /tmp/oct_TL9gjY.m. + % row vectors + a = [sym(1) 2]; + b = [sym(3) 4]; + assert (isequal ( [a b] , [1 2 3 4] )) + assert (isequal ( [a 3 4] , [1 2 3 4] )) + assert (isequal ( [3 4 a] , [3 4 1 2] )) + assert (isequal ( [a [3 4]] , [1 2 3 4] )) + assert (isequal ( [a sym(3) 4] , [1 2 3 4] )) + assert (isequal ( [a [sym(3) 4]] , [1 2 3 4] )) ***** test - % output to disk: also works with .m specified - if (exist ('OCTAVE_VERSION', 'builtin')) - temp_file = [tempname('', 'oct_') '.m']; - else - temp_file = [tempname() '.m']; - end - % allow loading function from temp_file - [temp_path, ans, ans] = fileparts(temp_file); - addpath(temp_path); - f = function_handle(2*x*y, 2^x, 'vars', {x y z}, 'file', temp_file); - assert( isa(f, 'function_handle')) - addpath(temp_path); % Matlab 2014a needs this? - [a,b] = f(10,20,30); - assert (isnumeric (a) && isnumeric (b)) - assert (a == 400) - assert (b == 1024) - if (exist ('OCTAVE_VERSION', 'builtin')) - assert (unlink(temp_file) == 0) - else - delete (temp_file) - end - % remove temp_path from load path - rmpath(temp_path); -Wrote file /tmp/oct_sTEAhC.m. + % col vectors + a = [sym(1); 2]; + b = [sym(3); 4]; + assert (isequal ( [a b] , [1 3; 2 4] )) + assert (isequal ( [a b a] , [1 3 1; 2 4 2] )) ***** test - % non-scalar outputs - H = [x y z]; - M = [x y; z 16]; - V = [x;y;z]; - h = function_handle(H, M, V); - [t1,t2,t3] = h(1,2,3); - assert(isequal(t1, [1 2 3])) - assert(isequal(t2, [1 2; 3 16])) - assert(isequal(t3, [1;2;3])) + % empty vectors + v = sym(1); + a = [v []]; + assert (isequal (a, v)) + a = [[] v []]; + assert (isequal (a, v)) + a = [v [] []]; + assert (isequal (a, v)) ***** test - % non-scalar outputs in .m files - H = [x y z]; - M = [x y; z 16]; - V = [x;y;z]; - if (exist ('OCTAVE_VERSION', 'builtin')) - temp_file = tempname('', 'oct_'); - else - temp_file = tempname(); - end - % allow loading function from temp_file - [temp_path, ans, ans] = fileparts(temp_file); - addpath(temp_path); - h = function_handle(H, M, V, 'vars', {x y z}, 'file', temp_file); - assert( isa(h, 'function_handle')) - addpath(temp_path); % Matlab 2014a needs this? - [t1,t2,t3] = h(1,2,3); - assert(isequal(t1, [1 2 3])) - assert(isequal(t2, [1 2; 3 16])) - assert(isequal(t3, [1;2;3])) - if (exist ('OCTAVE_VERSION', 'builtin')) - assert (unlink([temp_file '.m']) == 0) - else - delete ([temp_file '.m']) - end - % remove temp_path from load path - rmpath(temp_path); -Wrote file /tmp/oct_Es1s1I.m. + % more empty vectors + v = [sym(1) sym(2)]; + q = sym(ones(1, 0)); + assert (isequal ([v q], v)) +***** error + v = [sym(1) sym(2)]; + q = sym(ones(3, 0)); + w = horzcat(v, q); ***** test - % order of outputs is lexiographic - syms a A x y - f = y + 10*a + 100*x + 1000*A; - h = function_handle(f); - assert (h(1, 2, 3, 4) == 1000 + 20 + 300 + 4) + % issue #700 + A = sym ([1 2]); + B = simplify (A); + assert (isequal ([B A], [A B])) +8 tests, 8 passed, 0 known failure, 0 skipped +[inst/@sym/ztrans.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ztrans.m ***** test - % https://github.com/gnu-octave/symbolic/issues/854 - f = function_handle (x + 1i*sqrt (sym(3))); - assert (f (1), complex (1, sqrt (3)), -eps) -14 tests, 14 passed, 0 known failure, 0 skipped -[inst/@sym/symprod.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/symprod.m -***** error symprod (sym(1), 2, 3, 4, 5) + % basic Z-transform table checks + % X1, ..., X4 must have inner radius of convergence 1 + syms n z + % trick to extract the closed form formula using the fact that inner roc = 1 + closed_form = @(X) subs (X, abs (1 / z), 1 / sym (2)); + % check if ztrans(f) == X + check_ztrans = @(f, X) logical (simplify (closed_form (ztrans (f)) == X)); + f1 = sym (1); + X1 = 1 / (1 - 1 / z); + assert (check_ztrans (f1, X1)); + f2 = n; + X2 = (1 / z) / (1 - 1 / z)^2; + assert (check_ztrans (f2, X2)); + f3 = n^2; + X3 = (1 / z) * (1 + 1 / z) / (1 - 1 / z)^3; + assert (check_ztrans (f3, X3)); + f4 = n^3; + X4 = (1 / z) * (1 + 4 / z + 1 / z^2) / (1 - 1 / z)^4; + assert (check_ztrans (f4, X4)); + % basic matrix checks + A1 = ztrans ([f1 f2; f3 f4]); + B1 = [ztrans(f1) ztrans(f2); ztrans(f3) ztrans(f4)]; + assert (isequal (A1, B1)); + A2 = ztrans ([f1 f2; f3 f4], z); + B2 = [ztrans(f1, z) ztrans(f2, z); ztrans(f3, z) ztrans(f4, z)]; + assert (isequal (A2, B2)); + A3 = ztrans ([f1 f2; f3 f4], n, z); + B3 = [ztrans(f1, n, z) ztrans(f2, n, z); ztrans(f3, n, z) ztrans(f4, n, z)]; + assert (isequal (A3, B3)); ***** test - % simple - syms n - assert (isequal (symprod(n, n, 1, 10), factorial(sym(10)))) - assert (isequal (symprod(n, n, sym(1), sym(10)), factorial(10))) + % additional Z-transform table checks + % X1, ..., X4 must have inner radius of convergence a + syms n nonnegative integer + syms m positive integer + syms a + syms z + % trick to extract the closed form formula using the fact that inner roc = a + closed_form = @(X) subs (X, abs (a / z), 1 / sym (2)); + % check if ztrans(f) == X + check_ztrans = @(f, X) logical (simplify (closed_form (ztrans (f)) == X)); + f1 = a^n; + X1 = 1 / (1 - a / z); + assert (check_ztrans (f1, X1)); + f2 = n * a^n; + X2 = (a / z) / (1 - a / z)^2; + assert (check_ztrans (f2, X2)); + f3 = n^2 * a^n; + X3 = (a / z) * (1 + a / z) / (1 - a / z)^3; + assert (check_ztrans (f3, X3)); + f4 = nchoosek(n + m - 1, m - 1) * a^n; + X4 = 1 / (1 - a / z)^m; + assert (check_ztrans (f4, X4)); + % additional matrix checks + A1 = ztrans (f1, [n m; m n], [z a; a z]); + B1 = [ztrans(f1, n, z) ztrans(f1, m, a); ztrans(f1, m, a) ztrans(f1, n, z)]; + assert (isequal (A1, B1)); + A2 = ztrans (f1, m, [z a; a z]); + B2 = [ztrans(f1, m, z) ztrans(f1, m, a); ztrans(f1, m, a) ztrans(f1, m, z)]; + assert (isequal (A2, B2)); + A3 = ztrans (f1, [n m; m n], a); + B3 = [ztrans(f1, n, a) ztrans(f1, m, a); ztrans(f1, m, a) ztrans(f1, n, a)]; + assert (isequal (A3, B3)); ***** test - % one input - syms n - f = symprod (n); - g = factorial (n); - assert (isequal (f, g)) - f = symprod (2*n); - g = 2^n * factorial (n); - assert (isequal (f, g)) + % Kronecker delta checks + syms n n0 nonnegative integer + syms z + assert (isequal (ztrans (kroneckerDelta (n)), 1)); + assert (isequal (ztrans (kroneckerDelta (n - n0)), 1 / z^n0)); +***** test + % basic var selection checks + syms n m z w + assert (isequal (ztrans (1 / factorial (n)), exp (1 / z))); + assert (isequal (ztrans (1 / factorial (z)), exp (1 / w))); + assert (isequal (ztrans (1 / factorial (m), w), exp (1 / w))); + assert (isequal (ztrans (1 / factorial (m), m, w), exp (1 / w))); +***** test + % additional var selection checks + syms n m z + f = kroneckerDelta(m) / factorial (n); + assert (isequal (ztrans (f, z), exp (1 / z) * kroneckerDelta (m))); + assert (isequal (ztrans (f, n, z), exp (1 / z) * kroneckerDelta (m))); + assert (isequal (ztrans (f, m, z), 1 / factorial (n))); +***** test + % if no t, use symvar: take x before a + syms a x z + assert (isequal (ztrans (a / factorial (x)), a * exp (1 / z))); +***** error ztrans (sym ('n')^sym ('n', 'nonnegative', 'integer')) +7 tests, 7 passed, 0 known failure, 0 skipped +[inst/@sym/ellipticCPi.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipticCPi.m +***** error ellipticCPi (sym (1)) +***** error ellipticCPi (sym (1), 2, 3) +***** assert (double (ellipticCPi (0, sym (1)/2)), 1.854074677, 10e-10) +***** assert (double (ellipticCPi (sym (6)/10, sym(71)/10)), 1.29469534336658, -20*eps) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/permute.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/permute.m +***** error permute (sym(1)) +***** error permute (sym(1), 2, 3) +***** test + D = round(10*rand(5,3)); + A = sym(D); + B = permute(A, [1 2]); + assert (isequal(B, A)) + B = permute(A, [2 1]); + assert (isequal(B, A.')) ***** test - % constant input - f = symprod (sym(2)); syms x - g = 2^x; - assert (isequal (f, g)) + A = [1 x]; + B = permute(A, [2 1]); + assert (isequal(B, [1; x])) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/det.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/det.m +***** assert (isequal (det(sym([])), 1)) ***** test - % two inputs - syms n - f = symprod (2*n, n); - g = 2^n * factorial (n); - assert (isequal (f, g)) + syms x y real + assert (isequal (det([x 5; 7 y]), x*y-35)) ***** test - % two inputs, second is range - syms n - f = symprod (n, [1 6]); - g = 720; - assert (isequal (f, g)) - f = symprod (n, [sym(1) 6]); - g = 720; - assert (isequal (f, g)) - f = symprod (2*n, [1 6]); - g = sym(2)^6*720; - assert (isequal (f, g)) + syms x + assert (isequal (det(x), x)) + assert (isequal (det(sym(-6)), sym(-6))) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/colon.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/colon.m ***** test - % three inputs, last is range - syms n - f = symprod (2*n, n, [1 4]); - g = sym(384); - assert (isequal (f, g)) - f = symprod (2*n, n, [sym(1) 4]); - g = sym(384); - assert (isequal (f, g)) - f = symprod (2, n, [sym(1) 4]); - g = sym(16); - assert (isequal (f, g)) + a = sym(1):5; + b = sym(1:5); + assert(isequal(a,b)); + a = 1:sym(5); + b = sym(1:5); + assert(isequal(a,b)); ***** test - % three inputs, no range - syms n - f = symprod (2*n, 1, 4); - g = sym(384); - assert (isequal (f, g)) - f = symprod (5, sym(1), 3); - g = sym(125); - assert (isequal (f, g)) + a = 2:sym(2):8; + b = sym(2:2:8); + assert(isequal(a,b)); ***** test - % infinite product - syms a n oo - zoo = sym('zoo'); - assert (isequal (symprod(a, n, 1, oo), a^oo)) - assert (isequal (symprod(a, n, 1, inf), a^oo)) -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/cross.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cross.m -***** error cross (sym(1), 2, 3) + a = sym(10):-2:-4; + b = sym(10:-2:-4); + assert(isequal(a,b)); ***** test - a = sym([1; 0; 0]); - b = sym([0; 1; 0]); - c = cross(a, b); - assert (isequal (c, sym([0; 0; 1]))) + % symbolic intervals + p = sym(pi); + L = 0:p/4:p; + assert(isa(L,'sym')); + assert(isequal(L, [0 p/4 p/2 3*p/4 p])); ***** test + % mixed symbolic and double intervals + p = sym(pi); + s = warning ('off', 'OctSymPy:sym:rationalapprox'); + L = 0.1:(sym(pi)/3):2.3; + warning(s) + assert(isa(L,'sym')); + t = sym(1)/10; + assert(isequal(L, [t p/3+t 2*p/3+t])); +***** error syms x; a = 0:x; +***** error syms x; a = 1:x; +7 tests, 7 passed, 0 known failure, 0 skipped +[inst/@sym/mldivide.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/mldivide.m +***** test + % scalar syms x - a = sym([x; 0; 0]); - b = sym([0; 1; 0]); - c = cross(a, b); - assert (isequal (c, sym([0; 0; x]))) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/asech.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/asech.m -***** error asech (sym(1), 2) -***** assert (isequaln (asech (sym(nan)), sym(nan))) -***** shared x, d - d = 1/2; - x = sym('1/2'); + assert (isa( x\x, 'sym')) + assert (isequal( x\x, sym(1))) + assert (isa( 2\x, 'sym')) + assert (isa( x\2, 'sym')) ***** test - f1 = asech(x); - f2 = asech(d); - assert( abs(double(f1) - f2) < 1e-15 ) + % scalar \ matrix: easy, no system + D = 2*[0 1; 2 3]; + A = sym(D); + assert (isequal ( 2 \ A , D/2 )) + assert (isequal ( sym(2) \ A , D/2 )) ***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = asech(A); - f2 = asech(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) + % singular matrix + A = sym([1 2; 2 4]); + b = sym([5; 10]); + x = A \ b; + syms c1 + y = [-2*c1 + 5; c1]; + assert (isequal (x, y)) +***** test + % singular matrix, mult RHS + A = sym([1 2; 2 4]); + B = sym([[5; 10] [0; 2] [0; 0]]); + x = A \ B; + syms c1 c5 + y = [-2*c1 + 5 nan -2*c5; c1 nan c5]; + assert (isequaln (x, y)) +***** warning + % vpa, nearly singular matrix + A = sym([1 2; 2 4]); + A(1,1) = vpa('1.001'); + b = sym([1; 2]); + x = A \ b; + y = [sym(0); vpa('0.5')]; + assert (isequal (x, y)) +***** warning + % vpa, singular rhs + A = sym([1 2; 2 4]); + b = [vpa('1.01'); vpa('2')]; + x = A \ b; + assert (all(isnan(x))) +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@sym/eye.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/eye.m +***** test + y = eye(sym(2)); + x = [1 0; 0 1]; + assert( isequal( y, sym(x))) +***** test + y = eye(sym(2), 1); + x = [1; 0]; + assert( isequal( y, sym(x))) +***** test + y = eye(sym(1), 2); + x = [1 0]; + assert( isequal( y, sym(x))) +***** test + y = eye (sym([2 3])); + x = sym (eye ([2 3])); + assert (isequal (y, x)) +***** assert( isa( eye(sym(2), 'double'), 'double')) +***** assert( isa( eye(3, sym(3), 'single') , 'single')) +***** assert( isa( eye(3, sym(3)), 'sym')) +***** assert( isa( eye(3, sym(3), 'sym'), 'sym')) +***** xtest + % Issue #13 + assert( isa( eye(3, 3, 'sym'), 'sym')) +!!!!! known failure +invalid data type specified +9 tests, 8 passed, 1 known failure, 0 skipped +[inst/@sym/numden.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/numden.m +***** error numden (sym(1), 2) +***** test + syms x + [n, d] = numden (1/x); + assert (isequal (n, sym(1)) && isequal (d, x)) +***** test + syms x y + n1 = [sym(1); x]; + d1 = [x; y]; + [n, d] = numden (n1 ./ d1); + assert (isequal (n, n1) && isequal (d, d1)) +***** test + [n, d] = numden (sym(2)); + assert (isequal (n, 2)); + assert (isequal (d, 1)); +***** test + syms x y + [n, d] = numden ((x + pi)/(y + 6)); + assert (isequal (n, x + pi)); + assert (isequal (d, y + 6)); +***** test + syms x y + [n, d] = numden ((x^2 + y^2)/(x*y)); + assert (isequal (n, x^2 + y^2)); + assert (isequal (d, x*y)); +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@sym/isfinite.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isfinite.m +***** assert (isfinite(sym(1))) +***** assert (isfinite(sym(-10))) +***** assert (~isfinite(sym('oo'))) +***** assert (~isfinite(sym('-oo'))) +***** assert (~isfinite(sym(1)/0)) +***** assert (~isfinite(sym(nan))) +***** assert (isequal (isfinite (sym ([1 inf])), [true false])) +***** test + % finite-by-assumption + syms x finite + assert (isfinite (x)) +8 tests, 8 passed, 0 known failure, 0 skipped +[inst/@sym/formula.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/formula.m +***** test + syms x + assert (isequal (formula(x), x)) + assert (isequal (formula(2*x), 2*x)) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@sym/isNone.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isNone.m +***** test + None = pycall_sympy__ ('return None'); +***** shared None + None = pycall_sympy__ ('return None'); +***** assert (isNone(None)) +***** assert (~isNone(sym('x'))) +***** assert (islogical(isNone(None))) +***** test + a = [1 None]; + a = [None None]; + a = [None; 1]; + a = [None; None]; + a = [None 2; 3 None]; +***** test + a = sym([1 2]); + a(1,2) = None; + assert (isequal (a, [sym(1) None])); +***** assert (isequal (None(1), None)); +***** error None(None); +***** error x=sym('x'); x(None); +***** error x=1; x(None); +***** error None(None); +***** error 1 + None; +***** error None - 1; +***** error 6*None; +***** error 2^None; +***** error [1 2].*None; +***** error isconstant(None); +***** error nnz(None); +***** error logical(None); +***** error isAlways(None); +***** error logical([sym(true) None]); +***** error isAlways([sym(true) None]); +***** assert (isequal (children(None), None)) +***** assert (isequal (repmat(None, 1, 2), [None None])) +***** assert (isequal (fliplr(None), None)) +***** assert (isequal (flipud(None), None)) +26 tests, 26 passed, 0 known failure, 0 skipped +[inst/@sym/flipud.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/flipud.m +***** test + % simple + syms x + A = [x 2; sym(pi) x]; + B = [sym(pi) x; x 2]; + assert (isequal (flipud(A), B)) +***** test + % simple, odd # rows + syms x + A = [x 2; sym(pi) x; [1 2]]; + B = [[1 2]; sym(pi) x; x 2]; + assert (isequal (flipud(A), B)) +***** test + % scalar + syms x + assert (isequal (flipud(x), x)) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/pochhammer.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/pochhammer.m +***** error pochhammer (sym(1)) +***** error pochhammer (sym(1), 2, 3) +***** assert (isequal (pochhammer (sym(3), 4), sym(360))) +***** assert (isequal (pochhammer (sym([2 3]), 3), sym([24 60]))) ***** test % round trip - y = sym('y'); - A = asech (d); - f = asech (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) + syms n z + f = pochhammer (z, n); + h = function_handle (f, 'vars', [z n]); + A = h (1.1, 2.2); + B = pochhammer (1.1, 2.2); + assert (A, B) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/acos.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/acos.m -***** error acos (sym(1), 2) -***** assert (isequaln (acos (sym(nan)), sym(nan))) +[inst/@sym/rhs.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/rhs.m +***** test + syms x + f = x + 1 == 2*x; + assert (isequal (rhs(f), 2*x)) +***** error + syms x + rhs(x) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/cat.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cat.m +***** test + % mostly tested in horzcat, vertcat: one for good measure + syms x + assert (isequal (cat(1, x, x), [x x])) + assert (isequal (cat(2, x, x), [x; x])) +***** error cat(3, sym(2), sym(3)) +***** error cat(0, sym(2), sym(3)) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/round.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/round.m +***** test + d = 3/2; + x = sym('3/2'); + f1 = round(x); + f2 = round(d); + assert (isequal (f1, f2)) +***** xtest + % ideally rounding direction would match Octave + d = 5/2; + x = sym('5/2'); + f1 = round(x); + f2 = round(d); + assert (isequal (f1, f2)) +!!!!! known failure +assert (isequal (f1, f2)) failed +***** test + D = [1.1 4.6; -3.4 -8.9]; + A = [sym(11)/10 sym(46)/10; sym(-34)/10 sym(-89)/10]; + f1 = round(A); + f2 = round(D); + assert( isequal (f1, f2)) +***** test + d = sym(-11)/10; + c = -1; + assert (isequal (round (d), c)) +***** test + d = sym(-19)/10; + c = -2; + assert (isequal (round (d), c)) +***** test + d = 7j/2; + x = sym(7j)/2; + f1 = round (x); + f2 = round (d); + assert (isequal (f1, f2)) +***** test + d = 5/3 - 4j/7; + x = sym(5)/3 - sym(4j)/7; + f1 = round (x); + f2 = round (d); + assert (isequal (f1, f2)) +7 tests, 6 passed, 1 known failure, 0 skipped +[inst/@sym/laplace.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/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 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/@sym/fplot.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/fplot.m +***** test + % simple + syms x + f = cos (x); + fplot (f); +warning: using the gnuplot graphics toolkit is discouraged + +The gnuplot graphics toolkit is not actively maintained and has a number +of limitations that are unlikely to be fixed. Communication with gnuplot +uses a one-directional pipe and limited information is passed back to the +Octave interpreter so most changes made interactively in the plot window +will not be reflected in the graphics properties managed by Octave. For +example, if the plot window is closed with a mouse click, Octave will not +be notified and will not update its internal list of open figure windows. +The qt toolkit is recommended instead. +***** test + % constant function + fplot (sym (10)); + line 0: warning: iconv failed to convert degree sign + |--------------------------------------------------------------------| + 1 +|+ + + **** + + +-+| + | + + ** + ** + +-----------------+ | + #|############################*########*##########+***?***x) cos (x)+ | + #|###########################*##########*########################### | + #|##########################*############*########################## | + 0.5 +|+########################*##############*########################+-+| + #|########################*################*######################## | + *|########################*################*######################## *| + #|#######################*##################*#######################* | + #|######################**##################**######################* | + 0 +|*####################*######################*####################*-+| + #|*####################*######################*####################* | + #|#**#################*########################*#################**# | + #|##*#################*########################*#################*## | + #|###*###############*##########################*###############*### | + -0.5 +|+###*#############*############################*#############*###+-+| + #|####**###########*##############################*###########**#### | + #|#####*##########*################################*##########*##### | + #|######**#######*##################################*#######**###### | + #|--------------------------------------------------------------------| + -1 +-+####+###*****#####+#############+############+#####*****###+####+-+ + -4 -2 0 2 4 + +warning: fplot: FCN is not a vectorized function which reduces performance +warning: called from + fplot at line 172 column 7 + fplot at line 107 column 5 + __test__ at line 4 column 2 + test at line 682 column 11 + /tmp/tmp.wlPrNg8GOU at line 582 column 31 + +***** test + syms x + f = cos (x); + [xx, yy] = fplot (f); + assert (xx(1), -5) + assert (xx(end), 5) + assert (min (yy), -1, 0.1) + assert (max (yy), 1, 0.1) + line 0: warning: iconv failed to convert degree sign + |--------------------------------------------------------------------| + 11 +|+ + + + + + +-+| + | + + + + +------------+ | + #|#####################################################+***?***x) 10+ | + 10.5 +|+################################################################+-+| + #|################################################################## | + #|################################################################## | + #|################################################################## | + 10 *|********************************************************************| + #|################################################################## | + #|################################################################## | + 9.5 +|+################################################################+-+| + #|################################################################## | + #|################################################################## | + 9 +|+################################################################+-+| + #|################################################################## | + #|################################################################## | + #|################################################################## | + 8.5 +|+################################################################+-+| + #|################################################################## | + #|--------------------------------------------------------------------| + 8 +-+####+#############+#############+############+#############+####+-+ + -4 -2 0 2 4 + +***** test + syms x + f = cos (x); + dom = [1 3]; + [xx, yy] = fplot (f, dom); + assert (xx(1), dom(1)) + assert (xx(end), dom(2)) +***** test + syms x + f = cos (x); + dom = [1 3]; + fplot (f, dom); + assert (get (gca, 'xlim'), dom) +***** test + syms x + f = exp (x); + dom = [1 2 3 4]; + fplot (f, dom); + assert (get (gca, 'xlim'), dom(1:2)) + assert (get (gca, 'ylim'), dom(3:4)) + line 0: warning: iconv failed to convert degree sign + |--------------------------------------------------------------------| + 1 +|+ + + + +-+| + +| + + +-----------------++| + #|################################################+***?***x) cos (x)+ | + #|################################################################## | + #|################################################################## | + 0.5 *|**###############################################################+-+| + #|##**############################################################## | + #|####*****######################################################### | + #|#########***###################################################### | + #|############*****################################################# | + 0 +|+################**##############################################+-+| + #|###################*****########################################## | + #|########################***####################################### | + #|###########################**##################################### | + #|#############################*****################################ | + -0.5 +|+#################################*****##########################+-+| + #|#######################################**######################### | + #|#########################################*****#################### | + #|##############################################********############ | + +|--------------------------------------------------------------------| + -1 +-+##############+#################+################+##########******* + 1 1.5 2 2.5 3 + +***** test + % bounds as syms + syms x + f = cos (x); + dom = [1 2 3 4]; + fplot (f, sym (dom)); + assert (get (gca, 'xlim'), dom(1:2)) + assert (get (gca, 'ylim'), dom(3:4)) + line 0: warning: iconv failed to convert degree sign + |---------------------------------------------------------------------| + +| + *+ + + | + +| + * + + +-----------------+ | + #|#######################*#########################+***?***x) exp (x)+ | + #|######################*############################################ | + 3.8 +|+#####################*###########################################+-+| + #|#####################*############################################# | + #|####################*############################################## | + #|###################*############################################### | + 3.6 +|+#################*###############################################+-+| + #|#################*################################################# | + #|################*################################################## | + #|###############*################################################### | + 3.4 +|+############**###################################################+-+| + #|############*###################################################### | + #|###########*####################################################### | + #|##########*######################################################## | + 3.2 +|+########*########################################################+-+| + #|########*########################################################## | + #|######**########################################################### | + +|---------------------------------------------------------------------| + 3 +-+###*#######+#############+#############+#############+###########+-+ + 1 1.2 1.4 1.6 1.8 + +***** test + % bounds as syms, regular handle for function + % fails on 6.1.0, maybe earlier too? + if (compare_versions (OCTAVE_VERSION (), '6.1.0', '!=')) + dom = [1 2]; + fplot (@cos, sym (dom)); + assert (get (gca, 'xlim'), dom(1:2)) + end + line 0: warning: iconv failed to convert degree sign + |---------------------------------------------------------------------| + +| + + + + | + +| + + + +-----------------+ | + #|#################################################+***?***x) cos (x)+ | + #|################################################################### | + 3.8 +|+#################################################################+-+| + #|################################################################### | + #|################################################################### | + #|################################################################### | + 3.6 +|+#################################################################+-+| + #|################################################################### | + #|################################################################### | + #|################################################################### | + 3.4 +|+#################################################################+-+| + #|################################################################### | + #|################################################################### | + #|################################################################### | + 3.2 +|+#################################################################+-+| + #|################################################################### | + #|################################################################### | + +|---------------------------------------------------------------------| + 3 +-+###########+#############+#############+#############+###########+-+ + 1 1.2 1.4 1.6 1.8 + +***** error + syms x y + fplot (x*y) + line 0: warning: iconv failed to convert degree sign + |--------------------------------------------------------------------| + 0.8 +|+ + + + + +-+| + +| + + + + +----------+ | + 0.6 +|+######################################################+***?***cos++| + *|*################################################################# | + #|#*****############################################################ | + 0.4 +|+#####*****######################################################+-+| + #|###########**********############################################# | + 0.2 +|+####################*****#######################################+-+| + #|##########################*****################################### | + #|###############################****############################### | + 0 +|+##################################*****#########################+-+| + #|########################################*****##################### | + -0.2 +|+############################################*****###############+-+| + #|##################################################*****########### | + #|#######################################################**********# | + -0.4 +|+################################################################***| + #|################################################################## | + -0.6 +|+################################################################+-+| + #|################################################################## | + +|--------------------------------------------------------------------| + -0.8 +-+###########+#############+############+#############+###########+-+ + 1 1.2 1.4 1.6 1.8 + +***** test + % N parameter does something + syms x + [xx, yy] = fplot (sin (x), [0 2], 5); + N = length (xx); + assert (N >= 5) + [xx, yy] = fplot (sin (x), [0 2], 1000); + N = length (xx); + assert (N == 1000) +***** test + % tolerance parameter does something + syms x + [xx, yy] = fplot (sin (exp (x/2)), [0 3], 0.1); + N1 = length (xx); + [xx, yy] = fplot (sin (exp (x/2)), [0 3], 0.01); + N2 = length (xx); + assert (N2 > N1) +***** test + % fmt parameter does something + syms x + fplot (sin (x), [0 6], 'rx--', 'linewidth', 5); + l = get (gca (), 'children'); + assert (get (l, 'color'), [1 0 0]) + assert (get (l, 'linewidth'), 5) + f = exp (x); + dom = [1 2 3 4]; + fplot (f, dom); + assert (get (gca, 'xlim'), dom(1:2)) + assert (get (gca, 'ylim'), dom(3:4)) + line 0: warning: iconv failed to convert degree sign + |--------------------------------------------------------------------| + 1 +|+ + BBBB*BB + + + + +-+| + +| B*B BB + + +-----------------++| + #|########BB############*BB#######################+***B***x) sin (x)+ | + #|######*B#################B######################################## | + #|#####B####################B####################################### | + 0.5 +|+###B######################*B####################################+-+| + #|###B#########################B#################################### | + #|#*B###########################B################################### | + #|B##############################B################################## | + #|################################*B################################ | + 0 B|+#################################B##############################+-+| + #|###################################B############################## | + #|####################################B############################# | + #|#####################################B############################ B| + #|######################################*B##########################B | + -0.5 +|+#######################################B#######################*B-+| + #|#########################################B#####################B## | + #|##########################################B*B################BB### | + #|#############################################B#############*B##### | + +|--------------------------------------------------------------------| + -1 +-+#########+##########+###########+##########+#####BBBB*B+########+-+ + 0 1 2 3 4 5 6 + +***** test + close all +13 tests, 13 passed, 0 known failure, 0 skipped +[inst/@sym/ei.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ei.m +***** test + syms x + f = ei(sym(0)); + assert (double(f) == -inf) +***** test + D = [1.895117816355937 4.954234356001890]; + A = ei(sym([1 2])); + assert (all (abs(double(A) - D) < 1e-15)) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/erfc.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/erfc.m +***** error erfc (sym(1), 2) +***** assert (isequaln (erfc (sym(nan)), sym(nan))) ***** shared x, d d = 1; x = sym('1'); ***** test - f1 = acos(x); - f2 = acos(d); + f1 = erfc(x); + f2 = erfc(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = acos(A); - f2 = acos(D); + f1 = erfc(A); + f2 = erfc(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = acos (d); - f = acos (y); + A = erfc (d); + f = erfc (y); h = function_handle (f); B = h (d); assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/ellipticCK.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipticCK.m -***** error ellipticCK (sym (1), 2) -***** assert (double (ellipticCK (sym (1)/2)), 1.8541, 10e-5) -***** assert (double (ellipticCK (sym (101)/10)), 0.812691836806976, -3*eps) -***** assert (isequal (ellipticCK (sym (1)), sym(pi)/2)) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/flipud.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/flipud.m +[inst/@sym/besselh.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/besselh.m +***** test + % default to k=1 + syms z a + A = besselh(a, z); + B = besselh(a, 1, z); + assert (isequal (A, B)) +***** error besselh(sym('z')) +***** error besselh(2, 0, sym('z')) +***** error besselh(2, 3, sym('z')) +***** test + % doubles, relative error + X = [1 2 pi; 4i 5 6+6i]; + Xs = sym(X); + Alpha = [pi 3 1; 3 2 0]; + Alphas = sym(Alpha); + for k = 1:2 + A = double(besselh(Alphas, k, Xs)); + B = besselh(Alpha, k, X); + assert (all (all (abs(A - B) < 10*eps*abs(A)))) + end +***** test + % round-trip + syms x + for k = 1:2 + A = besselh(4, k, 10); + q = besselh(4, k, x); + h = function_handle(q); + B = h(10); + assert (abs(A - B) <= eps*abs(A)) + end +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@sym/hypergeom.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/hypergeom.m +***** assert (isequal (double (hypergeom ([1, 2], [2, 3], sym(0))), 1)) +***** test + % matrix input + syms z + a = sym([1 2]); + b = sym([3 4]); + A = hypergeom (a, b, [0 sym(1); 2 z]); + B = [hypergeom(a,b,0) hypergeom(a,b,1); hypergeom(a,b,2) hypergeom(a,b,z)]; + assert (isequal (A, B)) +***** test + % scalars for a and/or b + syms z + assert (isequal (hypergeom(1, 2, z), hypergeom({sym(1)}, {sym(2)}, z))) + assert (isequal (hypergeom([1 2], 3, z), hypergeom([1 2], {sym(3)}, z))) + assert (isequal (hypergeom(1, [2 3], z), hypergeom({sym(1)}, [2 3], z))) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/lt.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/lt.m ***** test % simple + x = sym(1); y = sym(1); e = x < y; + assert (~logical (e)) + x = sym(1); y = sym(2); e = x < y; + assert (logical (e)) +***** test + % mix sym and double + x = sym(1); y = 1; e = x < y; + assert (~logical (e)) + x = sym(1); y = 2; e = x < y; + assert (logical (e)) + x = 1; y = sym(1); e = x < y; + assert (~logical (e)) + x = 1; y = sym(2); e = x < y; + assert (logical (e)) +***** test + % Type of the output is sym or logical? + % FIXME: in current version, they are sym + x = sym(1); y = sym(1); e1 = x < y; + x = sym(1); y = sym(2); e2 = x < y; + %assert (islogical (e1)) + %assert (islogical (e2)) + assert (isa (e1, 'sym')) + assert (isa (e2, 'sym')) +***** test + % ineq w/ symbols + syms x y + e = x < y; + assert (~islogical (e)) + assert (isa (e, 'sym')) +***** test + % array -- array syms x - A = [x 2; sym(pi) x]; - B = [sym(pi) x; x 2]; - assert (isequal (flipud(A), B)) + a = sym([1 3 3 2*x]); + b = sym([2 x 3 10]); + e = a < b; + assert (isa (e, 'sym')) + assert (logical (e(1))) + assert (isa (e(2), 'sym')) + assert (isequal (e(2), 3 < x)) + assert (~logical (e(3))) + assert (isa (e(4), 'sym')) + assert (isequal (e(4), 2*x < 10)) ***** test - % simple, odd # rows + % array -- scalar + syms x oo + a = sym([1 x oo]); + b = sym(3); + e = a < b; + assert (isa (e, 'sym')) + assert (logical (e(1))) + assert (isa (e(2), 'sym')) + assert (isequal (e(2), x < 3)) + assert (~logical (e(3))) +***** test + % scalar -- array + syms x oo + a = sym(1); + b = sym([2 x -oo]); + e = a < b; + assert (isa (e, 'sym')) + assert (logical (e(1))) + assert (isa (e(2), 'sym')) + assert (isequal (e(2), 1 < x)) + assert (~logical (e(3))) +***** test + % ineq w/ nan syms x - A = [x 2; sym(pi) x; [1 2]]; - B = [[1 2]; sym(pi) x; x 2]; - assert (isequal (flipud(A), B)) + snan = sym(nan); + e = x < snan; + assert (~logical (e)) + e = snan < x; + assert (~logical (e)) + b = [sym(0) x]; + e = b < snan; + assert (isequal (e, [false false])) ***** test - % scalar + % oo + syms oo x + e = oo < x; + assert (isa (e, 'sym')) + assert (strcmp (strtrim (disp (e, 'flat')), 'oo < x')) +***** test + % sympy true matrix + a = sym([1 3 3]); + b = sym([2 4 1]); + e = a < b; + %assert (~isa (e, 'sym')) + %assert (islogical (e)) + assert (isequal (e, [true true false])) +***** test + % oo, finite real variables + syms oo + syms z real + assumeAlso(z, 'finite') + e = -oo < z; + assert (isequal (e, sym(true))) + e = z < oo; + assert (isequal (e, sym(true))) +***** test + % -oo, positive var (known failure w/ sympy 0.7.6.x) + syms oo + syms z positive + e = -oo < z; + assert (logical (e)) + assert (isequal (e, sym(true))) +***** test + % positive + syms z positive + e = -1 < z; + assert (isequal (e, sym(true))) +***** test + syms oo + z = sym('z', 'negative'); + e = z < oo; + assert (isequal (e, sym(true))) +14 tests, 14 passed, 0 known failure, 0 skipped +[inst/@sym/sympy.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sympy.m +***** assert (strcmp (sympy (sym(pi)), 'pi')) +***** assert (strcmp (sympy (sym(1)), 'Integer(1)')) +***** assert (strcmp (sympy (sym(2)/3), 'Rational(2, 3)')) +***** assert (strcmp (sympy (sym('x')), 'Symbol(''x'')')) +***** test + x = sym('x'); + assert (isequal (sym(sympy(x)), x)) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/children.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/children.m +***** test + % basics, sum + syms x y + f = 2*x + x*x + sin(y); + assert (isempty (setxor (children(f), [2*x x*x sin(y)]))) +***** test + % basics, product + syms x y + f = 2*x*sin(y); + assert (isempty (setxor (children(f), [2 x sin(y)]))) +***** test + % basics, product and powers + syms x y + f = 2*x^2*y^3; + assert (isempty (setxor (children(f), [2 x^2 y^3]))) +***** test + % eqn, ineq + syms x y + lhs = 2*x^2; rhs = y^3 + 7; + assert (isequal (children(lhs == rhs), [lhs rhs])) + assert (isequal (children(lhs < rhs), [lhs rhs])) + assert (isequal (children(lhs >= rhs), [lhs rhs])) +***** test + % matrix + syms x y + f = [4 + y 1 + x; 2 + x 3 + x]; + c = children(f); + ec = {[4 y], [1 x]; [2 x], [3 x]}; + assert (isequal (size(c), size(ec))) + for i=1:length(c) + assert (isempty (setxor (c{i}, ec{i}))) + end +***** test + % matrix, sum/prod + syms x y + f = [x + y; x*sin(y); sin(x)]; + ec = {[x y]; [x sin(y)]; [x]}; + c = children(f); + assert (isequal (size(c), size(ec))) + for i=1:length(c) + assert (isempty (setxor (c{i}, ec{i}))) + end +***** test + % scalar symbol syms x - assert (isequal (flipud(x), x)) -3 tests, 3 passed, 0 known failure, 0 skipped + assert (isequal (children(x), x)) +***** test + % scalar number + x = sym(6); + assert (isequal (children(x), x)) +***** test + % symbolic size matrix + syms n m integer + A = sym('a', [n m]); + C = children (A); + assert (isequal (C(2), n)) + assert (isequal (C(3), m)) +***** xtest + % symbolic size matrix, fails on newer SymPy Issue #1089 + syms n m integer + A = sym('a', [n m]); + assert (isequal (children (A), [sym('a') n m])) +!!!!! known failure +assert (isequal (children (A), [sym('a'), n, m])) failed +10 tests, 9 passed, 1 known failure, 0 skipped +[inst/@sym/max.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/max.m +***** test + % simple + assert (isequal (max([sym(10) sym(11)]), sym(11))) +***** test + syms x y + assert (isequal (children (max (x, y)), [x y])) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/isnan.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isnan.m +***** shared x,zoo,oo,snan + oo = sym(inf); + zoo = sym('zoo'); + x = sym('x'); + snan = sym(nan); +***** test + % various ops that give nan + assert (isnan(0*oo)) + assert (isnan(0*zoo)) + assert (isnan(snan)) + assert (isnan(snan-snan)) + assert (isnan(oo+snan)) + assert (isnan(oo-oo)) + assert (isnan(oo-zoo)) + assert (isnan(oo+zoo)) + assert (~isnan(oo)) + assert (~isnan(zoo)) + assert (~isnan(oo+oo)) +***** test + % more ops give nan + assert(isnan(x+snan)) + assert(isnan(x*snan)) + assert(isnan(0*snan)) + assert(isnan(x+nan)) + assert(isnan(x*nan)) + assert(isnan(sym(0)*nan)) +***** test + % array + assert (isequal( isnan([oo zoo]), [0 0] )) + assert (isequal( isnan([10 snan]), [0 1] )) + assert (isequal( isnan([snan snan]), [1 1] )) + assert (isequal( isnan([snan x]), [1 0] )) +***** test + % sub in to algebraic expression gives nan + y = x - oo; + y = subs(y, x, oo); + assert(isnan(y)) +***** test + % Must not contain string 'symbol'; these all should make an + % actual nan. Actually a ctor test, not isnan. + y = sym(nan); + assert (isempty (strfind (sympy (y), 'Symbol'))) + y = sym('nan'); + assert (isempty (strfind (sympy (y), 'Symbol'))) + y = sym('NaN'); + assert (isempty( strfind (sympy (y), 'Symbol'))) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/symreplace.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/symreplace.m +***** test + % start with assumptions on x then remove them + syms x positive + f = x*10; + symreplace(x, sym('x')) + assert(isempty(assumptions(x))) +***** test + % replace x with y + syms x + f = x*10; + symreplace(x, sym('y')) + assert( isequal (f, 10*sym('y'))) +***** test + % gets inside cells + syms x + f = {x 1 2 {3 4*x}}; + symreplace(x, sym('y')) + syms y + assert( isequal (f{1}, y)) + assert( isequal (f{4}{2}, 4*y)) +***** test + % gets inside structs/cells + syms x + my.foo = {x 1 2 {3 4*x}}; + my.bar = x; + g = {'ride' my 'motor' 'sicle'}; + symreplace(x, sym('y')) + syms y + f = g{2}; + assert( isequal (f.foo{1}, y)) + assert( isequal (f.foo{4}{2}, 4*y)) + assert( isequal (f.bar, y)) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/char.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/char.m +***** test + % issue #91: expose as string + a = sym(pi); + assert (strcmp (char (a), 'pi')) +***** shared x + x = sym('x'); +***** assert (strcmp (char (x), 'x')) +***** assert (strcmp (char (2*x), '2*x')) +***** assert (strcmp (char ([2*x x]), 'Matrix([[2*x, x]])')) +***** assert (strcmp (char ([2*x 2; 1 x]), 'Matrix([[2*x, 2], [1, x]])')) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/and.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/and.m +***** shared t, f + t = sym(true); + f = sym(false); +***** test + % simple + assert (isequal (t & f, f)) + assert (isequal (t & t, t)) +***** test + % mix with nonsym + assert (isequal (t & false, f)) + assert (isequal (t & true, t)) + assert (isequal (t & 0, f)) + assert (isequal (t & 1, t)) + assert (isa (t & false, 'sym')) + assert (isa (t & 1, 'sym')) +***** test + % array + w = [t t f f]; + z = [t f t f]; + assert (isequal (w & z, [t f f f])) +***** test + % number + assert (isequal( sym(1) & t, t)) + assert (isequal( sym(0) & t, f)) +***** test + % output is sym even for scalar t/f + assert (isa (t & f, 'sym')) +***** test + % eqns, exclusive + syms x + e = (x == 3) & (x^2 == 9); + assert (isequal (subs(e, x, [-3 0 3]), [f f t])) +***** error and (sym('x'), 2, 3) +7 tests, 7 passed, 0 known failure, 0 skipped +[inst/@sym/iscolumn.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/iscolumn.m +***** assert (iscolumn (sym ([1]))) +***** assert (iscolumn (sym ([1 2 3]'))) +***** assert (~iscolumn (sym ([]))) +***** assert (~iscolumn (sym ([1 2 3]))) +***** assert (~iscolumn (sym ([1 2; 3 4]))) +5 tests, 5 passed, 0 known failure, 0 skipped [inst/@sym/divergence.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/divergence.m ***** shared x,y,z @@ -3858,135 +6576,297 @@ ***** error divergence ([1 2], [sym('x')]) ***** error divergence ([1 2], sym('x'), 42) 7 tests, 7 passed, 0 known failure, 0 skipped -[inst/@sym/or.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/or.m -***** shared t, f - t = sym(true); - f = sym(false); +[inst/@sym/isinf.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isinf.m +***** shared x,zoo,oo,snan + oo = sym(inf); + zoo = sym('zoo'); + x = sym('x'); + snan = sym(nan); ***** test - % simple - assert (isequal (t | f, t)) - assert (isequal (t | t, t)) - assert (isequal (f | f, f)) + % various ops that give inf and nan + assert (isinf(oo)) + assert (isinf(zoo)) + assert (isinf(oo+oo)) + assert (~isinf(oo+zoo)) + assert (~isinf(0*oo)) + assert (~isinf(0*zoo)) + assert (~isinf(snan)) + assert (~isinf(oo-oo)) + assert (~isinf(oo-zoo)) ***** test - % array - w = [t t f f]; - z = [t f t f]; - assert (isequal (w | z, [t t t f])) + % arrays + assert (isequal( isinf([oo zoo]), [1 1] )) + assert (isequal( isinf([oo 1]), [1 0] )) + assert (isequal( isinf([10 zoo]), [0 1] )) + assert (isequal( isinf([x oo x]), [0 1 0] )) ***** test - % output is sym even for scalar t/f - assert (isa (t | f, 'sym')) + % Must not contain string 'symbol'; these all should make an + % actual infinity. Actually a ctor test, not isinf. + % IIRC, SMT in Matlab 2013b fails. + oo = sym(inf); + assert (isempty (strfind (sympy (oo), 'Symbol'))) + oo = sym(-inf); + assert (isempty (strfind (sympy (oo), 'Symbol'))) + oo = sym('inf'); + assert (isempty (strfind (sympy (oo), 'Symbol'))) + oo = sym('-inf'); + assert (isempty (strfind (sympy (oo), 'Symbol'))) + oo = sym('Inf'); + assert (isempty (strfind (sympy (oo), 'Symbol'))) ***** test - % eqns - syms x - e = or(x == 4, x == 5); - assert (isequal (subs(e, x, [3 4 5 6]), [f t t f])) -***** error or (sym(1), 2, 3) + % ops with infinity shouldn't collapse + syms x oo zoo + y = x + oo; + assert (~isempty (strfind (lower (sympy (y)), 'add') )) + y = x - oo; + assert (~isempty (strfind (lower (sympy (y)), 'add') )) + y = x - zoo; + assert (~isempty (strfind (lower (sympy (y)), 'add') )) + y = x*oo; + assert (~isempty (strfind (lower (sympy (y)), 'mul') )) +***** test + % ops with infinity are not necessarily infinite + syms x oo zoo + y = x + oo; + assert(~isinf(y)) % SMT 2014a says "true", I disagree + y = x - zoo; + assert(~isinf(y)) + y = x*oo; + assert(~isinf(y)) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/besselh.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/besselh.m +[inst/@sym/sign.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sign.m +***** error sign (sym(1), 2) +***** assert (isequaln (sign (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); ***** test - % default to k=1 - syms z a - A = besselh(a, z); - B = besselh(a, 1, z); - assert (isequal (A, B)) -***** error besselh(sym('z')) -***** error besselh(2, 0, sym('z')) -***** error besselh(2, 3, sym('z')) + f1 = sign(x); + f2 = sign(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - % doubles, relative error - X = [1 2 pi; 4i 5 6+6i]; - Xs = sym(X); - Alpha = [pi 3 1; 3 2 0]; - Alphas = sym(Alpha); - for k = 1:2 - A = double(besselh(Alphas, k, Xs)); - B = besselh(Alpha, k, X); - assert (all (all (abs(A - B) < 10*eps*abs(A)))) + D = [d d; d d]; + A = [x x; x x]; + f1 = sign(A); + f2 = sign(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) +***** test + % round trip + y = sym('y'); + A = sign (d); + f = sign (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/ellipke.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipke.m +***** error ellipke (sym(1), 2) +***** test + for i = 2:10 + [K E] = ellipke (sym (1)/i); + [k e] = ellipke (1/i); + assert (double ([K E]), [k e], 2*eps) end +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/acosd.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/acosd.m +***** error acosd (sym(1), 2) +***** assert (isequaln (acosd (sym(nan)), sym(nan))) +***** test + f1 = acosd (sym(1)/2); + f2 = acosd (1/2); + assert (double (f1), f2, -eps) +***** test + D = [1 2; 3 4]/4; + A = sym([1 2; 3 4])/4; + f1 = acosd (A); + f2 = acosd (D); + assert (double (f1), f2, -eps) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/expand.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/expand.m ***** test - % round-trip syms x - for k = 1:2 - A = besselh(4, k, 10); - q = besselh(4, k, x); - h = function_handle(q); - B = h(10); - assert (abs(A - B) <= eps*abs(A)) - end -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@sym/eye.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/eye.m + assert (logical (x^2 + 6*x + 5 == expand ((x+5)*(x+1)))) + assert (isequal (x^2 + 6*x + 5, expand ((x+5)*(x+1)))) ***** test - y = eye(sym(2)); - x = [1 0; 0 1]; - assert( isequal( y, sym(x))) + % array + syms x + assert (isequal (expand ([x (x+1)*x]), [x x^2+x])) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/logical.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/logical.m ***** test - y = eye(sym(2), 1); - x = [1; 0]; - assert( isequal( y, sym(x))) + % basics, many others in isAlways.m + assert (logical(true)) + assert (~(logical(false))) ***** test - y = eye(sym(1), 2); - x = [1 0]; - assert( isequal( y, sym(x))) + % numbers to logic? + assert (logical(sym(1))) + assert (logical(sym(-1))) + assert (~logical(sym(0))) ***** test - y = eye (sym([2 3])); - x = sym (eye ([2 3])); - assert (isequal (y, x)) -***** assert( isa( eye(sym(2), 'double'), 'double')) -***** assert( isa( eye(3, sym(3), 'single') , 'single')) -***** assert( isa( eye(3, sym(3)), 'sym')) -***** assert( isa( eye(3, sym(3), 'sym'), 'sym')) -***** xtest - % Issue #13 - assert( isa( eye(3, 3, 'sym'), 'sym')) -!!!!! known failure -invalid data type specified -9 tests, 8 passed, 1 known failure, 0 skipped -[inst/@sym/ellipticPi.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipticPi.m -***** error ellipticPi (sym (1)) -***** error ellipticPi (sym (1), 2, 3, 4) -***** assert (double (ellipticPi (sym (-23)/10, sym (pi)/4, 0)), 0.5876852228, 10e-11) -***** assert (double (ellipticPi (sym (1)/3, sym (pi)/3, sym (1)/2)), 1.285032276, 10e-11) -***** assert (double (ellipticPi (sym (2), sym (pi)/6, sym (2))), 0.7507322117, 10e-11) -***** xtest - % FIXME: search/report upstream - assert (double (ellipticPi (sym (-1), 0, sym (1))), 0) -!!!!! known failure -ASSERT errors for: assert (double (ellipticPi (sym (-1), 0, sym (1))),0) + % eqns, "structurally equivalent" + syms x + e = logical(x == x); + assert ( islogical (e)) + assert (e) + e = logical(x == 1); + assert ( islogical (e)) + assert (~e) +***** test + % eqn could have solutions but are false in general + syms x + e = logical(x^2 == x); + assert ( islogical (e)) + assert (~e) + e = logical(2*x == x); + assert ( islogical (e)) + assert (~e) +***** test + % FIXME: (not sure yet) T/F matrices should stay sym until logical() + a = sym(1); + e = a == a; + assert (isa (e, 'sym')) + assert (islogical (logical (e))) + e = [a == a a == 0 a == a]; + assert (isa (e, 'sym')) + assert (islogical (logical (e))) +***** test + % sym vectors of T/F to logical + a = sym(1); + e = [a == a a == 0 a == a]; + w = logical(e); + assert (islogical (w)) + assert (isequal (w, [true false true])) + e = e'; + w = logical(e); + assert (islogical (w)) + assert (isequal (w, [true; false; true])) +/usr/lib/python3/dist-packages/sympy/matrices/matrixbase.py:2051: SymPyDeprecationWarning: - Location | Observed | Expected | Reason - () NaN 0 'NaN' mismatch -***** xtest - % FIXME: this is a regression somewhere: loss of precision: Issue #1064 - % compare to Maple, complete - us = vpa (ellipticPi (sym(1)/6, sym(4)/3), 40); - % > evalf(EllipticPi(sin(1/6), sqrt(4/3)), 40); - maple = vpa ('2.019271696236161760696477679310987869058', 40) - ... - vpa ('1.708165765120289929280805062355360570830j', 40); - assert (abs (double (maple - us)), 0, 2e-39) -!!!!! known failure -ASSERT errors for: assert (abs (double (maple - us)),0,2e-39) +non-Expr objects in a Matrix is deprecated. Matrix represents +a mathematical matrix. To represent a container of non-numeric +entities, Use a list of lists, TableForm, NumPy array, or some +other data structure instead. - Location | Observed | Expected | Reason - () 5.7666e-32 0 Abs err 5.7666e-32 exceeds tol 2e-39 by 6e-32 +See https://docs.sympy.org/latest/explanation/active-deprecations.html#deprecated-non-expr-in-matrix +for details. + +This has been deprecated since SymPy version 1.9. It +will be removed in a future version of SymPy. + + out = self.from_dok(self.rows, self.cols, fdok) +***** test + % sym matrix of T/F to logical + a = sym([1 2 3; 4 5 6]); + b = sym([1 2 0; 4 0 6]); + e = a == b; + w = logical(e); + assert (islogical (w)) + assert (isequal (w, [true true false; true false true])) +***** error + syms x + logical(x); +***** error + logical(sym(nan)) +***** test + % but oo and zoo are non-zero so we call those true + % (SMT errors on these) FIXME + syms oo zoo + assert (logical (oo)) + % assert (logical (zoo)) +***** test + % older Octave (< 4.2) didn't automatically do "if (logical(obj))" + e = sym(true); + if (e) + assert(true); + else + assert(false); + end +***** test + % more of above + e2 = sym(1) == sym(1); + if (e2) + assert(true); + else + assert(false); + end + e3 = sym([1 2]) == sym([1 1]); + if (e3(1)) + assert(true); + else + assert(false); + end +12 tests, 12 passed, 0 known failure, 0 skipped +[inst/@sym/svd.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/svd.m +***** test + % basic + A = [1 2; 3 4]; + B = sym(A); + sd = svd(A); + s = svd(B); + s2 = double(s); + assert (norm(s2 - sd) <= 10*eps) +***** test + % scalars + syms x + syms y positive + a = sym(-10); + assert (isequal (svd(a), sym(10))) + assert (isequal (svd(x), sqrt(x*conj(x)))) + assert (isequal (svd(y), y)) ***** test - % compare to Maple, complete - us = vpa (ellipticPi (sym(1)/6, sym(4)/3), 40); - % > evalf(EllipticPi(sin(1/6), sqrt(4/3)), 40); - maple = vpa ('2.019271696236161760696477679310987869058', 40) - ... - vpa ('1.708165765120289929280805062355360570830j', 40); - assert (abs (double (maple - us)), 0, 2e-30) + % matrix with symbols + syms x positive + A = [x+1 0; sym(0) 2*x+1]; + s = svd(A); + s2 = subs(s, x, 2); + assert (isequal (s2, [sym(5); 3])) ***** test - % compare to Maple, incomplete - us = vpa (ellipticPi (sym(8)/7, sym(4)/3, sym(2)/7), 40); - % > evalf(EllipticPi(sin(4/3), 8/7, sqrt(2/7)), 40); - maple = vpa ('2.089415796799294830305265090302275542033', 40) - ... - vpa ('4.798862045930802761256228043192491271947j', 40); - assert (abs (double (maple - us)), 0, 6e-39) -9 tests, 7 passed, 2 known failures, 0 skipped + % matrix with symbols + syms x positive + A = [x+1 0; sym(0) 2*x+1]; + s = svd(A); + s2 = subs(s, x, 2); + assert (isequal (s2, [sym(5); 3])) +***** test + % matrix with symbols, nonneg sing values + syms x real + A = [x 0; 0 sym(-5)]; + s = svd(A); + assert (isequal (s, [abs(x); 5])) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/erfcinv.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/erfcinv.m +***** error erfcinv (sym(1), 2) +***** assert (isequaln (erfcinv (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); +***** test + f1 = erfcinv(x); + f2 = erfcinv(d); + assert( abs(double(f1) - f2) < 1e-15 ) +***** test + D = [d d; d d]; + A = [x x; x x]; + f1 = erfcinv(A); + f2 = erfcinv(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) +***** test + % round trip + y = sym('y'); + A = erfcinv (d); + f = erfcinv (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped [inst/@sym/real.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/real.m ***** assert (isequal (real (sym (4) + 3i),4)) @@ -4012,21 +6892,141 @@ B = h (d); assert (A, B) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/sind.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sind.m -***** error sind (sym(1), 2) -***** assert (isequaln (sind (sym(nan)), sym(nan))) +[inst/@sym/kron.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/kron.m +***** error kron (sym (2)) ***** test - f1 = sind (sym(1)); - f2 = sind (1); - assert (double (f1), f2, -eps) + syms x y + A = [sin(x), sin(y); x, y]; + B = ones(2); + expected = sym([sin(x), sin(x), sin(y), sin(y); sin(x), sin(x), sin(y), sin(y); x, x, y, y; x, x, y, y]); + assert (isequal (kron(A, B), expected)) ***** test - D = [10 30; 110 -45]; + syms x y + A = [sin(x), sin(y); x, y]; + B = 2; + assert (isequal (kron(A, B), 2*A)) +***** test + syms x y + A = [sin(x), sin(y)]; + B = 2; + assert (isequal( kron(B, A), 2*A)) +***** test + syms x y; + X = [tan(x), tan(x)]; + Y = [cot(x); cot(x)]; + expected = sym(ones(2)); + assert (isequal (simplify(kron(X, Y)), expected)) +***** test + syms x y z + X = [x, y, z]; + Y = [y, y; x, x]; + expected = [x*y, x*y, y^2, y^2, y*z, y*z; x^2, x^2, x*y, x*y, x*z, x*z]; + assert (isequal (kron(X, Y), expected)) +***** test + syms x y + X = [x, x^2; y, y^2]; + Y = [1, 0; 0, 1]; + expected = [x, x^2, 0, 0; y, y^2, 0, 0; 0, 0, x, x^2; 0, 0, y, y^2]; + assert (isequal (kron(Y, X), expected)) +***** test + syms x y z + assert (isequal (kron (x, y, z), x*y*z)) + assert (isequal (kron (x, y, z, 4), 4*x*y*z)) + assert (isequal (kron ([2 3], y, z), [2 3]*y*z)) + assert (isequal (kron ([2 3], [4; 5], y), [8 12; 10 15]*y)) +***** test + syms x y + A = kron ([x y], [1, -1; -1, 1], [2 3; 4 5]); + D = kron ([7 9], [1, -1; -1, 1], [2 3; 4 5]); + A = double (subs (A, [x y], [7 9])); + assert (isequal (A, D)) +9 tests, 9 passed, 0 known failure, 0 skipped +[inst/@sym/ldivide.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ldivide.m +***** test + % scalar + syms x + assert (isa (x .\ 1, 'sym')) + assert (isa (x .\ x, 'sym')) + assert (isequal (x .\ 1, 1/x)) + assert (isequal (x .\ x, sym(1))) +***** test + % matrix-scalar + D = [1 1; 2 3]; A = sym(D); - f1 = sind (A); - f2 = sind (D); - assert (double (f1), f2, -eps) + assert (isequal ( A .\ 6 , D .\ 6 )) + assert (isequal ( A .\ sym(6) , D .\ 6 )) + assert (isequal ( D .\ sym(6) , D .\ 6 )) +***** test + % matrix-matrix + D = [1 2; 3 4]; + A = sym(D); + assert (isequal ( A .\ A , D .\ D )) + assert (isequal ( A .\ D , D .\ D )) + assert (isequal ( D .\ A , D .\ D )) +***** test + % matrix .\ matrix with symbols + syms x y + A = [x y; x^2 2*y]; + B = [y x; x y]; + assert (isequal ( A .\ A , sym(ones(2, 2)) )) + assert (isequal ( B .\ A , [x/y y/x; x 2] )) +***** test + % scalar .\ matrix + D = 3*[1 2; 3 4]; + A = sym(D); + assert (isequal ( 3 .\ A , 3 .\ D )) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/beta.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/beta.m +***** error beta (sym(1), 2, 3) +***** assert (isequal (double (beta (sym(1), 2)), 1/2)) +***** assert (isinf (double (beta (sym(1), 0)))) +***** test + % round trip + syms x y + f = beta (x, y); + h = function_handle (f); + A = h (1.1, 2.2); + B = beta (1.1, 2.2); + assert (A, B) 4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/erf.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/erf.m +***** error erf (sym(1), 2) +***** assert (isequaln (erf (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); +***** test + f1 = erf(x); + f2 = erf(d); + assert( abs(double(f1) - f2) < 1e-15 ) +***** test + D = [d d; d d]; + A = [x x; x x]; + f1 = erf(A); + f2 = erf(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) +***** test + % round trip + y = sym('y'); + A = erf (d); + f = erf (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/argnames.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/argnames.m +***** test + % basic tests + syms x + f = 2*x; + assert (isempty (argnames(x))) + assert (isempty (argnames(f))) +1 test, 1 passed, 0 known failure, 0 skipped [inst/@sym/isequal.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isequal.m ***** test @@ -4059,87 +7059,219 @@ c(1) = 42; assert (~isequal (a, b, c)) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/iscolumn.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/iscolumn.m -***** assert (iscolumn (sym ([1]))) -***** assert (iscolumn (sym ([1 2 3]'))) -***** assert (~iscolumn (sym ([]))) -***** assert (~iscolumn (sym ([1 2 3]))) -***** assert (~iscolumn (sym ([1 2; 3 4]))) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/ellipke.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipke.m -***** error ellipke (sym(1), 2) +[inst/@sym/atan2.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/atan2.m +***** error atan2 (1) +***** error atan2 (1, 2, 3) ***** test - for i = 2:10 - [K E] = ellipke (sym (1)/i); - [k e] = ellipke (1/i); - assert (double ([K E]), [k e], 2*eps) - end -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/minus.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/minus.m + % some angles + e = sym(1); + a = atan2(0, e); + assert (isequal (a, sym(0))) + a = atan2(e, 0); + assert (isequal (a, sym(pi)/2)) +***** test + % symbols can give numerical answer + syms x positive + a = atan2(0, x); + assert (isequal (a, sym(0))) + a = atan2(x, 0); + assert (isequal (a, sym(pi)/2)) + a = atan2(-x, 0); + assert (isequal (a, -sym(pi)/2)) +***** test + % matrices + x = sym([1 -2; 0 0]); + y = sym([0 0; 8 -3]); + a = atan2(y, x); + sp = sym(pi); + aex = [0 sp; sp/2 -sp/2]; + assert (isequal (a, aex)) +***** test + % round trip + syms x y + xd = -2; yd = -3; + f = atan2 (x, y); + A = atan2 (xd, yd); + h = function_handle (f); + B = h (xd, yd); + assert (A, B, -eps) +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@sym/pinv.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/pinv.m ***** test % scalar syms x - assert (isa (x-1, 'sym')) - assert (isa (x-x, 'sym')) - assert (isequal (x-x, sym(0))) + assert (isequal (pinv(x), 1/x)) ***** test - % matrices - D = [0 1; 2 3]; - A = sym(D); - DZ = D - D; - assert (isequal ( A - D , DZ )) - assert (isequal ( A - A , DZ )) - assert (isequal ( D - A , DZ )) - assert (isequal ( A - 2 , D - 2 )) - assert (isequal ( 4 - A , 4 - D )) + % 2x3 + A = [1 2 3; 4 5 6]; + assert (max (max (abs (double (pinv (sym (A))) - pinv(A)))) <= 10*eps) 2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/abs.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/abs.m -***** error abs (sym(1), 2) -***** assert (isequaln (abs (sym(nan)), sym(nan))) +[inst/@sym/gammainc.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/gammainc.m +***** assert (isequal (gammainc (sym(0), 1), sym(0))) +***** assert (isequal (gammainc (sym(0), 2), sym(0))) +***** assert (isequal (gammainc (sym('oo'), 1), sym(1))) +***** assert (isequal (gammainc (sym(0), 1, 'upper'), sym(1))) +***** assert (isequal (gammainc (sym(0), 2, 'upper'), sym(1))) +***** assert (isequal (gammainc (sym('oo'), 1, 'upper'), sym(0))) +***** test + % default is lower + syms x a + assert (isequal (gammainc (x, a), gammainc(x, a, 'lower'))) +***** test + % compare to double + x = 5; a = 1; + A = gammainc (x, a); + B = double (gammainc (sym(x), a)); + assert(A, B, -eps) +***** test + % compare to double where gamma(a) != 1 + x = 5; a = 3; + A = gammainc (x, a); + B = double (gammainc (sym(x), a)); + assert(A, B, -eps) +***** test + % compare to double + x = 100; a = 1; + A = gammainc (x, a); + B = double (gammainc (sym(x), a)); + assert(A, B, -eps) +***** test + % compare to double + xs = sym(1)/1000; x = 1/1000; a = 1; + A = gammainc (x, a); + B = double (gammainc (xs, a)); + assert(A, B, -eps) +***** test + % compare to double + x = 5; a = 1; + A = gammainc (x, a, 'upper'); + B = double (gammainc (sym(x), a, 'upper')); + assert(A, B, -10*eps) +***** test + % compare to double + x = 10; a = 1; + A = gammainc (x, a, 'upper'); + B = double (gammainc (sym(x), a, 'upper')); + assert(A, B, -10*eps) +***** test + % compare to double + x = 40; a = 1; + A = gammainc (x, a, 'upper'); + B = double (gammainc (sym(x), a, 'upper')); + assert(A, B, -10*eps) +***** test + % compare to double + xs = sym(1)/1000; x = 1/1000; a = 1; + A = gammainc (x, a, 'upper'); + B = double (gammainc (xs, a, 'upper')); + assert(A, B, -eps) +***** test + % vectorized + P = gammainc([sym(pi) 2], [1 3]); + expected = [gammainc(pi, sym(1)) gammainc(2, sym(3))]; + assert (isequal (P, expected)) +***** test + % vectorized + P = gammainc(sym(pi), [1 3]); + expected = [gammainc(sym(pi), 1) gammainc(sym(pi), 3)]; + assert (isequal (P, expected)) +***** test + % vectorized + P = gammainc([sym(pi) 2], 1); + expected = [gammainc(pi, sym(1)) gammainc(2, sym(1))]; + assert (isequal (P, expected)) +***** test + % round trip + syms x a + f = gammainc (x, a, 'upper'); + h = function_handle (f, 'vars', [x a]); + A = h (1.1, 2); + B = gammainc (1.1, 2, 'upper'); + assert (A, B) +***** test + % round trip + syms x a + f = gammainc (x, a, 'lower'); + h = function_handle (f, 'vars', [x a]); + A = h (1.1, 2); + B = gammainc (1.1, 2, 'lower'); + assert (A, B) +***** test + % round trip + syms x a + f = gammainc (x, a, 'upper'); + h = function_handle (f, 'vars', [x a]); + A = h (1.1, 2.2); + B = gammainc (1.1, 2.2, 'upper'); + assert (A, B) +***** test + % round trip + syms x a + f = gammainc (x, a, 'lower'); + h = function_handle (f, 'vars', [x a]); + A = h (1.1, 2.2); + B = gammainc (1.1, 2.2, 'lower'); + assert (A, B) +22 tests, 22 passed, 0 known failure, 0 skipped +[inst/@sym/chebyshevU.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/chebyshevU.m +***** error chebyshevU (sym(1)) +***** error chebyshevU (sym(1), 2, 3) +***** assert (isequaln (chebyshevU (2, sym(nan)), sym(nan))) +***** shared x + syms x +***** assert(isequal(chebyshevU(0, x), sym(1))) +***** assert(isequal(chebyshevU(1, x), 2*x)) +***** assert(isequal(chebyshevU(2, x), 4*x*x - 1)) +***** assert(isequal(chebyshevU([0 1 2], x), [sym(1) 2*x (4*x*x-1)])) +***** test + % round trip + syms n z + f = chebyshevU (n, z); + h = function_handle (f, 'vars', [n z]); + A = h (1.1, 2.2); + B = chebyshevU (1.1, 2.2); + assert (A, B) +8 tests, 8 passed, 0 known failure, 0 skipped +[inst/@sym/uplus.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/uplus.m +***** test + syms x + assert (isa (+x, 'sym')) + assert (isequal (+x, x)) +***** test + A = sym([0 -1 inf]); + assert( isequal ( +A, A)) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/ceil.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ceil.m +***** error ceil (sym(1), 2) +***** assert (isequaln (ceil (sym(nan)), sym(nan))) ***** shared x, d - d = -1; - x = sym('-1'); + d = 3/2; + x = sym('3/2'); ***** test - f1 = abs(x); - f2 = abs(d); + f1 = ceil(x); + f2 = ceil(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = abs(A); - f2 = abs(D); + f1 = ceil(A); + f2 = ceil(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = abs (d); - f = abs (y); + A = ceil (d); + f = ceil (y); h = function_handle (f); B = h (d); assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/hypergeom.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/hypergeom.m -***** assert (isequal (double (hypergeom ([1, 2], [2, 3], sym(0))), 1)) -***** test - % matrix input - syms z - a = sym([1 2]); - b = sym([3 4]); - A = hypergeom (a, b, [0 sym(1); 2 z]); - B = [hypergeom(a,b,0) hypergeom(a,b,1); hypergeom(a,b,2) hypergeom(a,b,z)]; - assert (isequal (A, B)) -***** test - % scalars for a and/or b - syms z - assert (isequal (hypergeom(1, 2, z), hypergeom({sym(1)}, {sym(2)}, z))) - assert (isequal (hypergeom([1 2], 3, z), hypergeom([1 2], {sym(3)}, z))) - assert (isequal (hypergeom(1, [2 3], z), hypergeom({sym(1)}, [2 3], z))) -3 tests, 3 passed, 0 known failure, 0 skipped [inst/@sym/mpower.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/mpower.m ***** test @@ -4207,248 +7339,6 @@ A = sym([1 2; 3 4]); B = A^A; 9 tests, 8 passed, 1 known failure, 0 skipped -[inst/@sym/piecewise.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/piecewise.m -***** test - % basic - syms x real - f = piecewise (abs (x) < 1, 1); - assert (isnan (subs (f, -1))); - assert (isequal (subs (f, 0), 1)); - assert (isnan (subs (f, 1))); -***** test - % heaviside - syms x real - f = rewrite (heaviside (x, 1 / sym (2)), 'Piecewise'); - g = piecewise (x < 0, 0, x == 0, 1 / sym (2), x > 0, 1); - assert (logical (simplify (f == g))); -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/igamma.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/igamma.m -***** test - % mostly tested in @sym/gammainc - syms x - assert (isequal (igamma (2, x), gammainc(x, 2, 'upper'))) -***** test - % unregularized - B = double (igamma (sym(3), 1)); - A = gammainc (1, 3, 'upper')*gamma (3); - assert (A, B, -2*eps) -***** test - % something like a round trip: no igamma() - syms x a - f = igamma (a, x); - h = function_handle (f, 'vars', [a x]); - A = h (1.1, 2.2); - B = double (igamma (sym(11)/10, sym(22)/10)); - C = gammainc (2.2, 1.1, 'upper')*gamma(1.1); - assert (A, B, -10*eps) - assert (A, C, -10*eps) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/conj.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/conj.m -***** test - a = sym(6); - b = sym(5i); - assert (isequal (conj(a), a)) - assert (isequal (conj(b), -b)) - assert (isequal (conj(a+b), a-b)) -***** test - syms x - assert (isequal (conj(conj(x)), x)) -***** test - syms x real - assert (isequal (conj(x), x)) -***** test - % array - syms x - A = [x 6+1i; sym(1) x+2i]; - B = [conj(x) 6-1i; sym(1) conj(x)-2i]; - assert (isequal (conj(A), B)) -***** test - % true/false - t = sym(true); - f = sym(false); - assert (isequal ( conj(t), t)) - assert (isequal ( conj(f), f)) -***** test - % round trip - syms x - d = 3 - 5i; - f = conj (x); - A = conj (d); - h = function_handle (f); - B = h (d); - assert (A, B) -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@sym/numel.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/numel.m -***** test - a = sym([1 2 3]); - assert(numel(a) == 3); -***** test - % 2D array - a = sym([1 2 3; 4 5 6]); - assert(numel(a) == 6); -***** test - % empty - a = sym([]); - assert(numel(a) == 0); -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/erfc.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/erfc.m -***** error erfc (sym(1), 2) -***** assert (isequaln (erfc (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); -***** test - f1 = erfc(x); - f2 = erfc(d); - assert( abs(double(f1) - f2) < 1e-15 ) -***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = erfc(A); - f2 = erfc(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) -***** test - % round trip - y = sym('y'); - A = erfc (d); - f = erfc (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/isempty.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isempty.m -***** shared se, a - se = sym ([]); - a = sym ([1 2]); -***** assert (~isempty (sym (1))) -***** assert (isempty (sym (se))) -***** assert (isempty (se == [])) -***** test -***** test se(1) = 10; -***** test assert ( isa (se, 'sym')) -***** test assert ( isequal (se, 10)) -***** shared -***** test - % empty matrices - A = sym('A', [3 0]); - assert (isempty (A)) - A = sym(ones(3,0)); - assert (isempty (A)) -***** test - % non-empty symbolic-size matrices - syms n integer - A = sym('A', [3 n]); - assert (~isempty (A)) -***** xtest - % empty symbolic-size matrices - % FIXME: will fail until size stop lying by saying 1x1 - syms n integer - A = sym('A', [0 n]); - assert (isempty (A)) - A = sym('A', [n 0]); - assert (isempty (A)) -!!!!! known failure -assert (isempty (A)) failed -10 tests, 9 passed, 1 known failure, 0 skipped -[inst/@sym/toeplitz.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/toeplitz.m -***** test - % rect - R = [10 20 40]; C = [10 30]; - A = sym(toeplitz(R,C)); - B = toeplitz(sym(R),sym(C)); - assert (isequal (A, B)) - R = [10 20]; C = [10 30 50]; - A = sym(toeplitz(R,C)); - B = toeplitz(sym(R),sym(C)); - assert (isequal (A, B)) -***** test - % symbols - syms x y - R = [10 20 40]; C = [10 30]; - Rs = [10 x 40]; Cs = [10 y]; - A = toeplitz(R,C); - B = toeplitz(Rs,Cs); - assert (isequal (A, subs(B,[x,y],[20 30]))) -***** test - % hermitian - syms a b c - A = [a b c; conj(b) a b; conj(c) conj(b) a]; - B = toeplitz([a,b,c]); - assert (isequal( A, B)) -***** warning - % mismatch - syms x - B = toeplitz([10 x], [1 3 x]); -***** warning - % scalar - B = toeplitz(sym(2), 3); - assert (isequal (B, sym(2))) -***** test - % mismatch - syms x y - fprintf('\n one warning expected\n') % how to quiet this one? - A = toeplitz([10 2], [1 3 5]); - s = warning ('off', 'OctSymPy:toeplitz:diagconflict'); - B = toeplitz([10 x], [1 3 y]); - warning(s) - assert (isequal (A, subs(B, [x,y], [2 5]))) - - one warning expected -warning: toeplitz: column wins diagonal conflict -warning: called from - toeplitz at line 84 column 7 - __test__ at line 6 column 4 - test at line 682 column 11 - /tmp/tmp.fXtefQ8zRW at line 350 column 31 - -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@sym/adjoint.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/adjoint.m -***** test - syms x - A = [x x^2; x^3 x^4]; - B = [x^4 -x^2; -x^3 x]; - assert( isequal( adjoint(A), B )) -***** test syms x - assert( isequal( adjoint(x), 1)) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/log2.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/log2.m -***** assert (isequal (log2 (sym (1024)), sym (10))) -***** assert (isequal (log2 (sym ([2 16; 32 1])), sym ([1 4; 5 0]))) -***** test - % round-trip - syms x - f = log2 (x); - h = function_handle (f); - A = h (1.1); - B = log2 (1.1); - assert (A, B, -5*eps) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/permute.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/permute.m -***** error permute (sym(1)) -***** error permute (sym(1), 2, 3) -***** test - D = round(10*rand(5,3)); - A = sym(D); - B = permute(A, [1 2]); - assert (isequal(B, A)) - B = permute(A, [2 1]); - assert (isequal(B, A.')) -***** test - syms x - A = [1 x]; - B = permute(A, [2 1]); - assert (isequal(B, [1; x])) -4 tests, 4 passed, 0 known failure, 0 skipped [inst/@sym/end.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/end.m ***** test @@ -4475,1242 +7365,1230 @@ y = A(end); assert (isequal (y, sym(9))) 4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/size.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/size.m -***** test - a = sym([1 2 3]); - [n,m] = size(a); - assert (n == 1 && m == 3) -***** test - a = sym([1 2 3]); - n = size(a); - assert (isequal (n, [1 3])) -***** test - %% size, numel, length - a = sym([1 2 3; 4 5 6]); - assert (isa (size(a), 'double')) - assert (isa (numel(a), 'double')) - assert (isa (length(a), 'double')) - assert (isequal (size(a), [2 3])) - assert (length(a) == 3) - assert (numel(a) == 6) - a = sym([1; 2; 3]); - assert (isequal (size(a), [3 1])) - assert (length(a) == 3) - assert (numel(a) == 3) -***** test - %% size by dim - a = sym([1 2 3; 4 5 6]); - n = size(a, 1); - assert (n == 2) - m = size(a, 2); - assert (m == 3) - a = sym([1 2 3]'); - n = size(a, 1); - assert (n == 3) - m = size(a, 2); - assert (m == 1) -***** xtest - % symbolic-size matrices - syms n m integer - A = sym('A', [n m]); - d = size(A); - assert (~isa(d, 'sym')) - assert (isnumeric(d)) - assert (isequaln (d, [NaN NaN])) -!!!!! known failure -assert (isequaln (d, [NaN, NaN])) failed -***** xtest - % half-symbolic-size matrices - % FIXME: will fail until size stop lying by saying 1x1 - syms n integer - A = sym('A', [n 3]); - assert (isequaln (size(A), [NaN 3])) - A = sym('A', [4 n]); - assert (isequaln (size(A), [4 NaN])) -!!!!! known failure -assert (isequaln (size (A), [NaN, 3])) failed -***** xtest - % half-symbolic-size empty matrices - % FIXME: will fail until size stop lying by saying 1x1 - syms n integer - A = sym('A', [n 0]); - assert (isequaln (size(A), [NaN 0])) -!!!!! known failure -assert (isequaln (size (A), [NaN, 0])) failed -7 tests, 4 passed, 3 known failures, 0 skipped -[inst/@sym/mldivide.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/mldivide.m -***** test - % scalar - syms x - assert (isa( x\x, 'sym')) - assert (isequal( x\x, sym(1))) - assert (isa( 2\x, 'sym')) - assert (isa( x\2, 'sym')) -***** test - % scalar \ matrix: easy, no system - D = 2*[0 1; 2 3]; - A = sym(D); - assert (isequal ( 2 \ A , D/2 )) - assert (isequal ( sym(2) \ A , D/2 )) -***** test - % singular matrix - A = sym([1 2; 2 4]); - b = sym([5; 10]); - x = A \ b; - syms c1 - y = [-2*c1 + 5; c1]; - assert (isequal (x, y)) +[inst/@sym/prevprime.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/prevprime.m +***** assert (isequal (prevprime(sym(3)), 2)); +***** assert (isequal (prevprime(sym(20)), 19)); +***** assert (isequal (prevprime(sym([3 5 10])), [2 3 7])); +***** error prevprime(sym(2)) +***** error prevprime(sym(-2)) ***** test - % singular matrix, mult RHS - A = sym([1 2; 2 4]); - B = sym([[5; 10] [0; 2] [0; 0]]); - x = A \ B; - syms c1 c5 - y = [-2*c1 + 5 nan -2*c5; c1 nan c5]; - assert (isequaln (x, y)) -***** warning - % vpa, nearly singular matrix - A = sym([1 2; 2 4]); - A(1,1) = vpa('1.001'); - b = sym([1; 2]); - x = A \ b; - y = [sym(0); vpa('0.5')]; - assert (isequal (x, y)) -***** warning - % vpa, singular rhs - A = sym([1 2; 2 4]); - b = [vpa('1.01'); vpa('2')]; - x = A \ b; - assert (all(isnan(x))) + % result is a sym + p = prevprime(sym(3)); + assert (isa (p, 'sym')) 6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@sym/acosd.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/acosd.m -***** error acosd (sym(1), 2) -***** assert (isequaln (acosd (sym(nan)), sym(nan))) +[inst/@sym/adjoint.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/adjoint.m ***** test - f1 = acosd (sym(1)/2); - f2 = acosd (1/2); - assert (double (f1), f2, -eps) + syms x + A = [x x^2; x^3 x^4]; + B = [x^4 -x^2; -x^3 x]; + assert( isequal( adjoint(A), B )) +***** test syms x + assert( isequal( adjoint(x), 1)) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/ccode.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ccode.m +***** shared x,y,z + syms x y z ***** test - D = [1 2; 3 4]/4; - A = sym([1 2; 3 4])/4; - f1 = acosd (A); - f2 = acosd (D); - assert (double (f1), f2, -eps) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/pretty.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/pretty.m + % basic test + f = x*sin(y) + abs(z); + source = ccode(f); + expected = 'x*sin(y) + fabs(z)'; + assert(strcmp(source, expected)) ***** test - % simple - syms x - s1 = pretty(sin(x)); - s2 = sprintf(' sin(x)\n'); - assert (strcmp (s1, s2)) + % output test + f = x*sin(y) + abs(z); + [C, H] = ccode(f, 'file', '', 'show_header', false); + expected_c_code = sprintf('#include \"file.h\"\n#include \n\ndouble myfun(double x, double y, double z) {\n\n double myfun_result;\n myfun_result = x*sin(y) + fabs(z);\n return myfun_result;\n\n}\n'); + expected_h_code = sprintf('\n#ifndef PROJECT__FILE__H\n#define PROJECT__FILE__H\n\ndouble myfun(double x, double y, double z);\n\n#endif\n\n'); + assert(strcmp(C.name, 'file.c')) + assert(strcmp(H.name, 'file.h')) + hwin = strrep(expected_h_code, sprintf('\n'), sprintf('\r\n')); + assert (strcmp (H.code, expected_h_code) || strcmp (H.code, hwin)) + s1 = expected_c_code; + s2 = strrep(expected_c_code, sprintf('\n'), sprintf('\r\n')); + assert (strcmp (C.code, s1) || strcmp (C.code, s2)) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/vertcat.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/vertcat.m ***** test - % force ascii + % basic syms x - s1 = pretty(sin(x/2), 'ascii'); - s2 = sprintf(' /x\\\n sin|-|\n \\2/\n'); - swin = strrep(s1, sprintf('\r\n'), sprintf('\n')); - assert (strcmp (s1, s2) || strcmp (swin, s2)) + A = [x; x]; + B = vertcat(x, x); + C = vertcat(x, x, x); + assert (isa (A, 'sym')) + assert (isa (B, 'sym')) + assert (isa (C, 'sym')) + assert (isequal (size(A), [2 1])) + assert (isequal (size(B), [2 1])) + assert (isequal (size(C), [3 1])) ***** test - % force unicode + % basic, part 2 syms x - s1 = pretty(sin(x/2), 'unicode'); - s2 = sprintf(' ⎛x⎞\n sin⎜─⎟\n ⎝2⎠\n'); - swin = strrep(s1, sprintf('\r\n'), sprintf('\n')); - assert (strcmp (s1, s2) || strcmp (swin, s2)) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/ones.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ones.m + A = [x; 1]; + B = [1; x]; + C = [1; 2; x]; + assert (isa (A, 'sym')) + assert (isa (B, 'sym')) + assert (isa (C, 'sym')) + assert (isequal (size(A), [2 1])) + assert (isequal (size(B), [2 1])) + assert (isequal (size(C), [3 1])) ***** test - y = ones(sym(2)); - x = [1 1; 1 1]; - assert( isequal( y, sym(x))) + % column vectors + a = [sym(1); 2]; + b = [sym(3); 4]; + assert (isequal ( [a;b] , [1; 2; 3; 4] )) + assert (isequal ( [a;b;a] , [1; 2; 3; 4; 1; 2] )) ***** test - y = ones(sym(2), 1); - x = [1; 1]; - assert( isequal( y, sym(x))) + % row vectors + a = [sym(1) 2]; + b = [sym(3) 4]; + assert (isequal ( [a;b] , [1 2; 3 4] )) + assert (isequal ( [a;b;a] , [1 2; 3 4; 1 2] )) ***** test - y = ones(sym(1), 2); - x = [1 1]; - assert( isequal( y, sym(x))) + % row vector, other row + a = [sym(1) 2]; + assert (isequal ( [a; [sym(3) 4]] , [1 2; 3 4] )) ***** test - y = ones (sym([2 3])); - x = sym (ones ([2 3])); - assert (isequal (y, x)) -***** assert( isa( ones(sym(2), 'double'), 'double')) -***** assert( isa( ones(3, sym(3), 'single') , 'single')) -***** assert( isa( ones(3, sym(3)), 'sym')) -***** assert( isa( ones(3, sym(3), 'sym'), 'sym')) + % empty vectors + v = [sym(1) sym(2)]; + a = [v; []]; + assert (isequal (a, v)) + a = [[]; v; []]; + assert (isequal (a, v)) + a = [v; []; []]; + assert (isequal (a, v)) ***** xtest - % Issue #13 - assert( isa( ones(3, 3, 'sym'), 'sym')) + % FIXME: is this Octave bug? worth worrying about + syms x + a = [x; [] []]; + assert (isequal (a, x)) !!!!! known failure -invalid data type specified -9 tests, 8 passed, 1 known failure, 0 skipped -[inst/@sym/partfrac.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/partfrac.m +octave_base_value::map_value(): wrong type argument 'null_matrix' ***** test - % basic - syms x y z - assert(logical( partfrac(y/(x + 2)/(x + 1),x) == -y/(x + 2) + y/(x + 1) )) - assert(logical( factor(partfrac(x^2/(x^2 - y^2),y)) == factor(x/(2*(x + y)) + x/(2*(x - y)) ))) - assert(logical( factor(partfrac(x^2/(x^2 - y^2),x)) == factor(-y/(2*(x + y)) + y/(2*(x - y)) + 1 ))) -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@sym/isconstant.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isconstant.m + % more empty vectors + v = [sym(1) sym(2)]; + q = sym(ones(0, 2)); + assert (isequal ([v; q], v)) +***** error + v = [sym(1) sym(2)]; + q = sym(ones(0, 3)); + w = vertcat(v, q); ***** test + % Octave 3.6 bug: should pass on 3.8.1 and matlab + a = [sym(1) 2]; + assert (isequal ( [a; [3 4]] , [1 2; 3 4] )) + assert (isequal ( [a; sym(3) 4] , [1 2; 3 4] )) + % more examples syms x - A = [x 2 3]; - B = [false true true]; - assert (isequal (isconstant (A), B)) -/usr/lib/python3/dist-packages/sympy/matrices/matrixbase.py:2051: SymPyDeprecationWarning: - -non-Expr objects in a Matrix is deprecated. Matrix represents -a mathematical matrix. To represent a container of non-numeric -entities, Use a list of lists, TableForm, NumPy array, or some -other data structure instead. - -See https://docs.sympy.org/latest/explanation/active-deprecations.html#deprecated-non-expr-in-matrix -for details. - -This has been deprecated since SymPy version 1.9. It -will be removed in a future version of SymPy. - - out = self.from_dok(self.rows, self.cols, fdok) + [x [x x]; x x x]; + [[x x] x; x x x]; + [[x x] x; [x x] x]; + [x x x; [x x] x]; +***** test + % issue #700 + A = sym ([1 2]); + B = simplify (A); + assert (isequal ([B; A], [A; B])) +11 tests, 10 passed, 1 known failure, 0 skipped +[inst/@sym/dawson.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/dawson.m ***** test + if (exist ('OCTAVE_VERSION', 'builtin')) + % dawson missing on Matlab, Issue #742 + A = dawson([1 2]); + B = double(dawson(sym([1 2]))); + assert(A, B, -eps) + end +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@sym/simplify.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/simplify.m +***** shared x,p,q syms x - A = [x 2; 3 x]; - B = [false true; true false]; - assert (isequal (isconstant (A), B)) + p = x^2 + x + 1; + q = horner (p); +***** assert(~isequal( p - q, 0)) +***** assert(isequal( simplify(p - q), 0)) 2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/ellipticF.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipticF.m -***** error ellipticF (sym(1)) -***** error ellipticF (sym(1), 2, 3) -***** assert (double (ellipticF (sym (pi)/3, sym (-105)/10)), 0.6184459461, 10e-11) -***** assert (double (ellipticF (sym (pi)/4, sym (-pi))), 0.6485970495, 10e-11) -***** assert (double (ellipticF (sym (1), sym (-1))), 0.8963937895, 10e-11) -***** assert (double (ellipticF (sym (pi)/6, sym (0))), 0.5235987756, 10e-11) -***** test - % compare to Maple - us = vpa (ellipticF (sym(11)/10, sym(9)/4), 40); - % > evalf(EllipticF(sin(11/10), sqrt(9/4)), 40); - maple = vpa ('1.206444996991058996424988192917728014427', 40) - ... - vpa ('0.8157358125823472313001683083685348517476j', 40); - assert (abs (double (maple - us)), 0, 1e-39) -7 tests, 7 passed, 0 known failure, 0 skipped -[inst/@sym/mod.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/mod.m -***** error mod (sym(1), 2, 3 ,4) -***** assert (isequal (mod (sym(5), 4), sym(1))) -***** assert (isequal (mod ([sym(5) 8], 4), [1 0] )) -***** assert (isequal (mod (sym(5), [2 3]), [1 2] )) -***** assert (isequal (mod ([sym(5) sym(6)], [2 3]), [1 0] )) +[inst/@sym/subsindex.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/subsindex.m ***** test - syms x - assert (isequal ( mod (5*x, 3), 2*x )) + i = sym(1); + a = 7; + assert(a(i)==a); + i = sym(2); + a = 2:2:10; + assert(a(i)==4); ***** test - syms x - a = [7*x^2 + 3*x + 3 3*x; 13*x^4 6*x]; - assert (isequal ( mod (a,3), [x^2 0; x^4 0] )) + i = sym([1 3 5]); + a = 1:10; + assert( isequal (a(i), [1 3 5])) ***** test - % vector of polys with mix of vars: symvar on each - syms x y - a = [6*x 7*y]; - b = mod(a, 4); - c = [2*x 3*y]; - assert (isequal (b, c)) + i = sym([1 3 5]); + a = sym(1:10); + assert( isequal (a(i), sym([1 3 5]))); ***** test - % coeff has variable + % should be an error if it doesn't convert to double syms x - n = sym('n', 'integer'); - p = (3*n + 2)*x; - q = mod(p, 3); - assert (isequal (q, 2*x)) + a = 1:10; + try + a(x) + waserr = false; + catch + waserr = true; + end + assert(waserr) ***** test - % coeff has variable - syms x a - p = a*x; - q = mod(p, 3); - q = children(q); - q = q(2); % order might be fragile! - w = subs(q, a, 5); - assert (isequal (w, 2)) + syms x + assert (isequal (x(sym (true)), x)) + assert (isequal (x(sym (false)), sym ([]))) ***** test - % different modulo - syms x y - q = mod([5*x + 10 5*y + 10], [2 3]); - assert (isequal (q, [x 2*y + 1])) -11 tests, 11 passed, 0 known failure, 0 skipped -[inst/@sym/isNone.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isNone.m + x = 6; + assert (isequal (x(sym (true)), 6)) + assert (isequal (x(sym (false)), [])) ***** test - None = pycall_sympy__ ('return None'); -***** shared None - None = pycall_sympy__ ('return None'); -***** assert (isNone(None)) -***** assert (~isNone(sym('x'))) -***** assert (islogical(isNone(None))) + a = sym([10 12 14]); + assert (isequal (a(sym ([true false true])), a([1 3]))) + assert (isequal (a(sym ([false false false])), sym (ones(1,0)))) ***** test - a = [1 None]; - a = [None None]; - a = [None; 1]; - a = [None; None]; - a = [None 2; 3 None]; + a = [10 11; 12 13]; + p = [true false; true true]; + assert (isequal (a(sym (p)), a(p))) + p = [false false false]; + assert (isequal (a(sym (p)), a(p))) +***** error + a = [10 12]; + I = [sym(true) 2]; + b = a(I); +9 tests, 9 passed, 0 known failure, 0 skipped +[inst/@sym/tand.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/tand.m +***** error tand (sym(1), 2) +***** assert (isequaln (tand (sym(nan)), sym(nan))) ***** test - a = sym([1 2]); - a(1,2) = None; - assert (isequal (a, [sym(1) None])); -***** assert (isequal (None(1), None)); -***** error None(None); -***** error x=sym('x'); x(None); -***** error x=1; x(None); -***** error None(None); -***** error 1 + None; -***** error None - 1; -***** error 6*None; -***** error 2^None; -***** error [1 2].*None; -***** error isconstant(None); -***** error nnz(None); -***** error logical(None); -***** error isAlways(None); -***** error logical([sym(true) None]); -***** error isAlways([sym(true) None]); -***** assert (isequal (children(None), None)) -***** assert (isequal (repmat(None, 1, 2), [None None])) -***** assert (isequal (fliplr(None), None)) -***** assert (isequal (flipud(None), None)) -26 tests, 26 passed, 0 known failure, 0 skipped -[inst/@sym/isrow.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isrow.m -***** assert (isrow (sym ([1]))) -***** assert (isrow (sym ([1 2 3]))) -***** assert (~isrow (sym ([]))) -***** assert (~isrow (sym ([1 2 3]'))) -***** assert (~isrow (sym ([1 2; 3 4]))) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/imag.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/imag.m -***** assert (isequal (imag (sym (4) + 3i),3)) + f1 = tand (sym(1)); + f2 = tand (1); + assert (double (f1), f2, -eps) ***** test - syms x y real - z = x + 1i*y; - assert (isequal (imag (z),y)) + D = [10 30; 110 -45]; + A = sym(D); + f1 = tand (A); + f2 = tand (D); + assert (double (f1), f2, -eps) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/fix.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/fix.m ***** test - syms x y real - Z = [4 x + 1i*y; 1i*y 4 + 3i]; - assert (isequal (imag (Z),[0 y; y 3])) + d = 3/2; + x = sym('3/2'); + f1 = fix(x); + f2 = fix(d); + assert (isequal (f1, f2)) ***** test - syms x real - d = exp (x*i); - assert (isequal (imag (d), sin (x))) + D = [1.1 4.6; -3.4 -8.9]; + A = [sym(11)/10 sym(46)/10; sym(-34)/10 sym(-89)/10]; + f1 = fix(A); + f2 = fix(D); + assert( isequal (f1, f2)) ***** test - % round trip - syms x - d = 3 - 5i; - f = imag (x); - A = imag (d); - h = function_handle (f); - B = h (d); - assert (A, B) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/hypot.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/hypot.m -***** assert (isequal (hypot (sym(3), 4), sym(5))) + d = sym(-11)/10; + c = -1; + assert (isequal (fix (d), c)) ***** test - % compare to @double (note Matlab hypot only takes 2 inputs) - A = hypot (hypot ([1 2 3], [4 5 6]), [7 8 9]); - B = double (hypot (sym([1 2 3]), [4 5 6], [7 8 9])); - assert (A, B, -eps) + d = sym(-19)/10; + c = -1; + assert (isequal (fix (d), c)) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/ezcontour.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ezcontour.m +***** error + syms x y z + ezcontour (x*y*z) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@sym/cond.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cond.m ***** test - % compare to @double, with complex - A = hypot ([1+2i 3+4i], [1 3+1i]); - B = double (hypot (sym([1+2i 3+4i]), [1 3+1i])); - assert (A, B, -eps) + A = [1 2; 3 4]; + B = sym(A); + k1 = cond(A); + k2 = cond(B); + k3 = double(k2); + assert (k1 - k3 <= 100*eps) ***** test - % matrices - x = sym([1 -2; 0 3]); - y = sym([0 0; 8 4]); - A = hypot (x, y); - B = sym([1 2; 8 5]); - assert (isequal (A, B)) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/asinh.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/asinh.m -***** error asinh (sym(1), 2) -***** assert (isequaln (asinh (sym(nan)), sym(nan))) + % matrix with symbols + syms x positive + A = [x 0; sym(0) 2*x]; + k1 = cond(A); + assert (isequal (k1, sym(2))) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/sin.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sin.m +***** error sin (sym(1), 2) +***** assert (isequaln (sin (sym(nan)), sym(nan))) ***** shared x, d d = 1; x = sym('1'); ***** test - f1 = asinh(x); - f2 = asinh(d); + f1 = sin(x); + f2 = sin(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = asinh(A); - f2 = asinh(D); + f1 = sin(A); + f2 = sin(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = asinh (d); - f = asinh (y); + A = sin (d); + f = sin (y); h = function_handle (f); B = h (d); assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/erf.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/erf.m -***** error erf (sym(1), 2) -***** assert (isequaln (erf (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); +[inst/@sym/dot.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/dot.m +***** error dot (sym(1), 2, 3) ***** test - f1 = erf(x); - f2 = erf(d); - assert( abs(double(f1) - f2) < 1e-15 ) + a = sym([1; 1; 0]); + b = sym([1; 2; 4]); + c = dot(a, b); + assert (isequal (c, sym(3))) ***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = erf(A); - f2 = erf(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) + syms x + a = sym([x; 0; 0]); + b = sym([0; 1; 0]); + c = dot(a, b); + assert (isequal (c, sym(0))) ***** test - % round trip - y = sym('y'); - A = erf (d); - f = erf (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/unique.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/unique.m + assert (isequal (dot (sym([1 i]), sym([i 2])), sym(-i))) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/ellipticE.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipticE.m +***** error ellipticE (sym(1), 2, 3) +***** assert (double (ellipticE (sym (-105)/10)), 3.70961391, 10e-9) +***** assert (double (ellipticE (sym (-pi)/4)), 1.844349247, 10e-10) +***** assert (double (ellipticE (sym (0))), 1.570796327, 10e-10) +***** assert (double (ellipticE (sym (1))), 1, 10e-1) ***** test - A = sym([1 2 3 3 5 3 2 6 5]); - B = sym([1 2 3 5 6]); - assert (isequal (unique(A), B)) + % compare to Maple + us = vpa (ellipticE (sym(7)/6, sym(13)/7), 40); + % > evalf(EllipticE(sin(7/6), sqrt(13/7)), 40); + maple = vpa ('0.6263078268598504591831743625971763209496', 40) + ... + vpa ('0.1775496232203171126975790989055865596501j', 40); + assert (abs (double (maple - us)), 0, 2e-39) ***** test - syms x y - A = [1 2 3 3 4 5 5 6 7 7 x x y y]; - B = [1 2 3 4 5 6 7 x y]; - assert (isequal (unique(A), B)) + % compare to Maple + us = vpa (ellipticE (sym(8)/7), 40); + % > evalf(EllipticE(sqrt(8/7)), 40); + maple = vpa ('0.8717182992576322508542205614105802333270', 40) + ... + vpa ('0.1066754320328976949531350910798010526685j', 40); + assert (abs (double (maple - us)), 0, 2e-39) +7 tests, 7 passed, 0 known failure, 0 skipped +[inst/@sym/null.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/null.m ***** test - syms x - assert (isequal (unique(x), x)) + A = sym([1 2; 3 4]); + assert (isempty (null (A))) +***** assert (isempty (null (sym(4)))) +***** test + A = sym([1 2 3; 3 4 5]); + assert (isequal (null(A), sym([1;-2;1]))) 3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/expand.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/expand.m +[inst/@sym/subsasgn.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/subsasgn.m +***** shared a,b + b = [1:4]; + a = sym(b); +***** test a(1) = 10; b(1) = 10; + assert(isequal( a, b )) +***** test I = logical([1 0 1 0]); + a(I) = 2; b(I) = 2; + assert(isequal( a, b )) +***** test I = logical([1 0 1 0]); + a(I) = [2 4]; b(I) = [2 4]; + assert(isequal( a, b )) +***** test I = logical([1 0 1 0]); + a(I) = [2; 4]; b(I) = [2; 4]; + assert(isequal( a, b )) +***** shared ***** test - syms x - assert (logical (x^2 + 6*x + 5 == expand ((x+5)*(x+1)))) - assert (isequal (x^2 + 6*x + 5, expand ((x+5)*(x+1)))) + b = 1:4; b = [b; 2*b; 3*b]; + a = sym(b); + rhs = [10 11; 12 13]; + a([1:2],[1:2]) = rhs; + b([1:2],[1:2]) = rhs; + assert(isequal( a, b )) + a(1:2,1:2) = rhs; + assert(isequal( a, b )) ***** test - % array - syms x - assert (isequal (expand ([x (x+1)*x]), [x x^2+x])) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/prevprime.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/prevprime.m -***** assert (isequal (prevprime(sym(3)), 2)); -***** assert (isequal (prevprime(sym(20)), 19)); -***** assert (isequal (prevprime(sym([3 5 10])), [2 3 7])); -***** error prevprime(sym(2)) -***** error prevprime(sym(-2)) + % slice : + b = 1:4; b = [b; 2*b]; + a = sym(b); + rhs = [10 11; 12 13]; + a(:,2:3) = rhs; + b(:,2:3) = rhs; + assert(isequal( a, b )) ***** test - % result is a sym - p = prevprime(sym(3)); - assert (isa (p, 'sym')) -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@sym/uminus.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/uminus.m + % grow 2D + b = 1:4; b = [b; 2*b]; + a = sym(b); + rhs = [10 11; 12 13]; + a([1 end+1],end:end+1) = rhs; + b([1 end+1],end:end+1) = rhs; + assert(isequal( a, b )) ***** test - % scalar + % grow from nothing + clear a + a(3) = sym (1); + b = sym ([0 0 1]); + assert (isequal (a, b)) +***** test + % grow from nothing, 2D + clear a + a(2, 3) = sym (1); + b = sym ([0 0 0; 0 0 1;]); + assert (isequal (a, b)) +***** test + % linear indices of 2D + b = 1:4; b = [b; 2*b; 3*b]; + a = sym(b); + b(1:4) = [10 11 12 13]; + a(1:4) = [10 11 12 13]; + assert(isequal( a, b )) + b(1:4) = [10 11; 12 13]; + a(1:4) = [10 11; 12 13]; + assert(isequal( a, b )) +***** error + % Wrong shape matrix RHS: Matlab/Octave don't allow this on doubles. + % Matlab SMT 2013b gets it wrong. We throw an error. + rhs = [10 11; 12 13]; + a = sym (magic (3)); + a(1:2,1:2) = rhs(:); +***** test + % Issue #963: vector RHS with diff orientation from 2D indexing + b = 1:4; b = [b; 2*b; 3*b]; + a = sym(b); + b(1:2:3, 1) = 11:2:13; + a(1:2:3, 1) = sym(11:2:13); + assert (isequal (a, b)) + b(1:2:3, 1) = 1:2:3; + a(1:2:3, 1) = 1:2:3; + assert (isequal (a, b)) +***** test + % Issue #963: vector RHS with diff orientation from 2D indexing + a = sym (magic (3)); + b = a; + a(1:2:3, 2) = [14 15]; + b(1:2:3, 2) = [14; 15]; + assert (isequal (a, b)) + a(2, 1:2:3) = [24 25]; + b(2, 1:2:3) = [24; 25]; + assert (isequal (a, b)) +***** test + % 1D growth and 'end' + g = sym([1 2 3]); + g(3:4) = [67 68]; + g(end:end+1) = [12 14]; + assert(isequal( g, [1 2 67 12 14] )) +***** test + % expanding empty and scalar syms x - assert (isa (-x, 'sym')) - assert (isequal (-(-x), x)) + c = sym([]); + c(1) = x; + assert(isequal( c, x )) + c(2) = 2*x; + assert(isequal( c, [x 2*x] )) +***** shared a,b,I,J + b = 1:4; b = [b; 3*b; 5*b]; a = sym(b); + I = logical([1 0 1]); + J = logical([1 0 1 0]); +***** assert(isequal( a(I,J), b(I,J) )) ***** test - % matrix - D = [0 1; 2 3]; - A = sym(D); - assert( isequal( -A, -D )) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/mtimes.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/mtimes.m + rhs = [90 91; 92 93]; + b(I, J) = rhs; + a(I, J) = rhs; + assert(isequal( a, b )) ***** test - % scalar + b(I, J) = 100; + a(I, J) = 100; + assert(isequal( a, b )) +***** shared +***** test + % logical with all false syms x - assert (isa (x*2, 'sym')) - assert (isequal (2*sym(3), sym(6))) - assert (isequal (sym(2)*3, sym(6))) + y = x; + y(false) = 6; + assert(isequal( y, x )); + a = [x x]; + a([false false]) = [6 6]; + assert(isequal( a, [x x] )); ***** test - % matrix-scalar - D = [0 1; 2 3]; - A = sym(D); - assert (isa (2*A, 'sym')) - assert (isequal ( 2*A , 2*D )) - assert (isequal ( A*2 , 2*D )) + % issue #18, scalar access + syms x + x(1) = sym(6); + assert(isequal( x, sym(6) )); + x(1) = 6; + assert(isequal( x, sym(6) )); + x(true) = 88; + assert(isequal( x, sym(88) )); ***** test - % matrix-matrix - D = [0 1; 2 3]; - A = sym(D); - assert (isa (A*A, 'sym')) - assert (isequal ( A*A , D*D )) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/taylor.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/taylor.m + % bug: assignment to column vector used to fail + A = sym(zeros(3,1)); + A(1) = 5; ***** test + % symfun creation (generic function) syms x - f = exp(x); - expected = 1 + x + x^2/2 + x^3/6 + x^4/24 + x^5/120; - assert (isequal (taylor(f), expected)) - assert (isequal (taylor(f,x), expected)) - assert (isequal (taylor(f,x,0), expected)) + g(x) = x*x; + assert(isa(g,'symfun')) +***** test + % symfun creation (generic function) + syms x g(x) + assert(isa(g,'symfun')) ***** test + % symfun creation when g already exists and is a sym/symfun syms x - f = exp(x); - expected = 1 + x + x^2/2 + x^3/6 + x^4/24; - assert (isequal (taylor(f,'order',5), expected)) - assert (isequal (taylor(f,x,'order',5), expected)) - assert (isequal (taylor(f,x,0,'order',5), expected)) + g = x; + syms g(x) + assert(isa(g,'symfun')) + clear g + g(x) = x; + g(x) = x*x; + assert(isa(g,'symfun')) ***** test - % key/value ordering doesn't matter + % Issue #443: assignment with sym indices + A = sym([10 11]); + A(sym(1)) = 12; + assert (isequal (A, sym([12 11]))) +***** test + % Issue #443: assignment with sym indices + A = sym([10 11]); + A(sym(1), 1) = 12; + assert (isequal (A, sym([12 11]))) + A(sym(1), sym(1)) = 13; + assert (isequal (A, sym([13 11]))) +***** test + % Issue #443: assignment with sym indices, increase size + A = sym([10 11]); + A(sym(2), 1) = 12; + assert (isequal (A, sym([10 11; 12 0]))) +***** error + % Issue #443 + A = sym([10 11]); + A(2, sym('x')) = sym(12); +***** error + % Issue #443 + A = sym([10 11]); + A(sym(2), sym('x')) = sym(12); +***** error + % issue #445 + A = sym([10 11]); + A(1.1) = 13 +***** error + % issue #445 + A = sym([10 11]); + A(sym(pi)) = 13 +***** error + % issue #445 + A = sym([1 2; 3 4]); + A(1.3, 1.2) = 13 +***** test + % older expansion tests syms x - f = exp(x); - g1 = taylor(f, 'expansionPoint', 1, 'order', 3); - g2 = taylor(f, 'order', 3, 'expansionPoint', 1); - assert (isequal (g1, g2)) + f = [2*x 3*x]; + f(2) = 4*x; + assert (isequal (f, [2*x 4*x])) + f(2) = 2; + assert (isequal(f, [2*x 2])) + g = f; + g(1,3) = x*x; + assert (isequal(g, [2*x 2 x^2])) + g = f; + g(3) = x*x; + assert (isequal(g, [2*x 2 x^2])) + g = f; + g(3) = 4; + assert (isequal(g, [2*x 2 4])) ***** test + % older slicing tests syms x - f = x^2; - assert (isequal (taylor(f,x,0,'order',0), 0)) - assert (isequal (taylor(f,x,0,'order',1), 0)) - assert (isequal (taylor(f,x,0,'order',2), 0)) - assert (isequal (taylor(f,x,0,'order',3), x^2)) - assert (isequal (taylor(f,x,0,'order',4), x^2)) + f = [1 x^2 x^4]; + f(1:2) = [x x]; + assert (isequal( f, [x x x^4] )) + f(1:2) = [1 2]; + assert (isequal( f, [1 2 x^4] )) + f(end-1:end) = [3 4]; + assert (isequal( f, [1 3 4] )) + f(3:4) = [10 11]; + assert (isequal( f, [1 3 10 11] )) + f(end:end+1) = [12 14]; + assert (isequal( f, [1 3 10 12 14] )) ***** test - syms x y - f = exp(x)+exp(y); - expected = 2 + x + x^2/2 + x^3/6 + x^4/24 + y + y^2/2 + y^3/6 + y^4/24; - assert (isAlways(taylor(f,[x,y],'order',5)== expected)) - assert (isAlways(taylor(f,[x,y],[0,0],'order',5) == expected)) + % struct.str = sym, sometimes calls subsasgn + d = struct(); + syms x + d.a = x; + assert (isa (d, 'struct')) + assert (isequal (d.a, x)) + d.('a') = x; + assert (isa (d, 'struct')) + assert (isequal (d.a, x)) + d = setfield(d, 'a', x); + assert (isa (d, 'struct')) + assert (isequal (d.a, x)) + % at least on Oct 3.8, this calls sym's subsasgn + d = struct(); + d = setfield(d, 'a', x); + assert (isa (d, 'struct')) + assert (isequal (d.a, x)) ***** test - % key/value ordering doesn't matter + % bool scalar assignments of true/false into sym syms x - f = exp(x); - g1 = taylor(f, 'expansionPoint', 1, 'order', 3); - g2 = taylor(f, 'order', 3, 'expansionPoint', 1); - assert (isequal (g1, g2)) + a = sym([1 2 x 3]); + b = [1 2 10 4]; + e = a == b; + assert (logical (e(2))) + e(2) = false; + assert (~logical (e(2))) ***** test + % bool vector assignments of true/false into sym syms x - f = x^2; - assert (isequal (taylor(f,x,0,'order',0), 0)) - assert (isequal (taylor(f,x,0,'order',1), 0)) - assert (isequal (taylor(f,x,0,'order',2), 0)) - assert (isequal (taylor(f,x,0,'order',3), x^2)) - assert (isequal (taylor(f,x,0,'order',4), x^2)) + a = sym([1 2 x 3]); + b = [1 2 10 4]; + e = a == b; + e(1:2) = [true true]; + assert (isequal (e, [sym(1)==1 sym(2)==2 x==10 sym(3)==4])) ***** test - % syms for a and order + % bool scalar promoted to vector assignments into sym syms x - f = x^2; - assert (isequal (taylor(f,x,sym(0),'order',sym(2)), 0)) - assert (isequal (taylor(f,x,sym(0),'order',sym(4)), x^2)) + a = sym([1 2 x 3]); + b = [1 2 10 4]; + e = a == b; + e(1:2) = true; + assert (isequal (e, [sym(1)==1 sym(2)==2 x==10 sym(3)==4])) ***** test - syms x y - f = exp (x^2 + y^2); - expected = 1+ x^2 +y^2 + x^4/2 + x^2*y^2 + y^4/2; - assert (isAlways(taylor(f,[x,y],'order',5)== expected)) - assert (isAlways(taylor(f,[x,y],'expansionPoint', [0,0],'order',5) == expected)) + % grow scalar equality expression into a matrix of equalities + syms a b c d + e = a == b; + e(2) = c == d; + assert (isequal (e, [a==b c==d])) +***** shared a, b, I + b = [1:4]; b = [b; 3*b; 5*b]; + a = sym(b); + I = mod (b, 5) > 1; ***** test - syms x y - f = sqrt(1+x^2+y^2); - expected = 1+ x^2/2 +y^2/2 - x^4/8 - x^2*y^2/4 - y^4/8; - assert (isAlways(taylor(f,[x,y],'order',6)== expected)) - assert (isAlways(taylor(f,[x,y],'expansionPoint', [0,0],'order',5) == expected)) + A = a; A(I) = 2*b(I); + B = b; B(I) = 2*b(I); + assert (isequal (A, B)) ***** test - syms x y - f = sin (x^2 + y^2); - expected = sin(sym(1))+2*cos(sym(1))*(x-1)+(cos(sym(1))-2*sin(sym(1)))*(x-1)^2 + cos(sym(1))*y^2; - assert (isAlways(taylor(f,[x,y],'expansionPoint', [1,0],'order',3) == expected)) + % scalar RHS + A = a; A(I) = 17; + B = b; B(I) = 17; + assert (isequal (A, B)) ***** test - % key/value ordering doesn't matter - syms x y - f = exp(x+y); - g1 = taylor(f, 'expansionPoint',1, 'order', 3); - g2 = taylor(f, 'order', 3, 'expansionPoint',1); - assert (isAlways(g1== g2)) + % nonetheless, above strange case should give right answer + I = logical([1 0 1 0; 0 1 0 1; 1 0 1 0]); + rhs = 2*b(I); + rhs2 = reshape(rhs, 2, 3); + A0 = a; A1 = a; + A0(I) = rhs; + A1(I) = rhs2; + assert (isequal (A0, A1)) +***** shared AA, BB + BB = [1 2 3; 4 5 6]; + AA = sym(BB); ***** test - syms x y - f = x^2 + y^2; - assert (isAlways(taylor(f,[x,y],[0,0],'order',0)== sym(0) )) - assert (isAlways(taylor(f,[x,y],[0,0],'order',1)== sym(0) )) - assert (isAlways(taylor(f,[x,y],[0,0],'order',2)== sym(0) )) - assert (isAlways(taylor(f,[x,y],[0,0],'order',3)== sym(x^2 + y^2))) - assert (isAlways(taylor(f,[x,y],[0,0],'order',4)== sym(x^2 + y^2))) + A = AA; B = BB; + B([1 6]) = [8 9]; + A([1 6]) = [8 9]; + assert (isequal (A, B)) ***** test - % expansion point - syms x a - f = x^2; - g = taylor(f,x,2); - assert (isequal (simplify(g), f)) - assert (isequal (g, 4*x+(x-2)^2-4)) - g = taylor(f,x,a); - assert (isequal (simplify(g), f)) + % rhs scalar + A = AA; B = BB; + B([1 6]) = 88; + A([1 6]) = 88; + assert (isequal (A, B)) ***** test - % wrong order-1 series with nonzero expansion pt: - % upstream bug https://github.com/sympy/sympy/issues/9351 - syms x - g = x^2 + 2*x + 3; - h = taylor (g, x, 4, 'order', 1); - assert (isequal (h, 27)) + % If rhs is not a vector, make sure col-based access works + rhs = [18 20; 19 21]; + A = AA; B = BB; + B([1 6]) = 88; + A([1 6]) = 88; + B([1 2 3 4]) = rhs; + A([1 2 3 4]) = rhs; + assert (isequal (A, B)) ***** test - syms x y z - g = x^2 + 2*y + 3*z; - h = taylor (g, [x,y,z], 'order', 4); - assert (isAlways(h == g)) ; + % Growth + A = AA; B = BB; + A(1,5) = 10; + B(1,5) = 10; + assert (isequal (A, B)) +***** shared ***** test - syms x y z - g = sin(x*y*z); - h = taylor (g, [x,y,z], 'order', 4); - assert (isAlways(h == x*y*z)) ; -***** error - syms x y - taylor(0, [x, y], [1, 2, 3]); -18 tests, 18 passed, 0 known failure, 0 skipped -[inst/@sym/all.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/all.m + % Check row deletion 1D + a = sym([1; 3; 5]); + b = sym([3; 5]); + a(1) = []; + assert( isequal( a, b)) ***** test - % matrix - a = [0 3; 1 2]; - s = sym (a); - assert (isequal (all (s), all (a))) - assert (isequal (all (s,1), all (a,1))) - assert (isequal (all (s,2), all (a,2))) + % Check column deletion 1D + a = sym([1, 4, 8]); + b = sym([4, 8]); + a(1) = []; + assert( isequal( a, b)) ***** test - % vector - a = [1 2 3]; - s = sym (a); - assert (isequal (all (s), all (a))) - assert (isequal (all (s,1), all (a,1))) - assert (isequal (all (s,2), all (a,2))) + % Check row deletion 2D + a = sym([1, 2; 3, 4]); + b = sym([3, 4]); + a(1, :) = []; + assert( isequal( a, b)) ***** test - % should fail on symbols - syms x - s = [1 2 x]; - try - all (s) - waserr = false; - catch - waserr = true; - end - assert (waserr) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/dirac.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/dirac.m -***** error dirac (sym(1), 2) -***** assert (isequaln (dirac (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); + % Check column deletion 2D + a = sym([1, 2; 3, 4]); + b = sym([2; 4]); + a(:, 1) = []; + assert( isequal( a, b)) ***** test - f1 = dirac(x); - f2 = dirac(d); - assert( abs(double(f1) - f2) < 1e-15 ) + % General assign + a = sym([1, 2; 3, 4]); + b = sym([5, 5; 5, 5]); + a(:) = 5; + assert( isequal( a, b)) ***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = dirac(A); - f2 = dirac(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) + % Empty matrix + a = sym([1, 2; 3, 4]); + a(:) = []; + assert( isequal( a, sym([]))) ***** test - % round trip - y = sym('y'); - A = dirac (d); - f = dirac (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/dawson.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/dawson.m + % Disassemble matrix + a = sym([1 2; 3 4; 5 6]); + b = sym([3 5 2 4 6]); + a(1) = []; + assert (isequal (a, b)); +***** error + a = sym([1, 2; 3, 4]); + a(1, 2) = []; ***** test - if (exist ('OCTAVE_VERSION', 'builtin')) - % dawson missing on Matlab, Issue #742 - A = dawson([1 2]); - B = double(dawson(sym([1 2]))); - assert(A, B, -eps) - end -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@sym/simplify.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/simplify.m -***** shared x,p,q - syms x - p = x^2 + x + 1; - q = horner (p); -***** assert(~isequal( p - q, 0)) -***** assert(isequal( simplify(p - q), 0)) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/floor.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/floor.m -***** error floor (sym(1), 2) -***** assert (isequaln (floor (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); + % Issue #964 + a = sym(10); + a(1) = []; + assert (isempty (a)) + assert (isequal (a, zeros(1, 0))) ***** test - f1 = floor(x); - f2 = floor(d); - assert( abs(double(f1) - f2) < 1e-15 ) + % Issue #963: scalar asgn to empty part of matrix + A = sym (magic (3)); + B = A; + A(1, []) = 42; + assert (isequal (A, B)) + A([], 2) = 42; + assert (isequal (A, B)) + A([]) = 42; + assert (isequal (A, B)) + A([], []) = 42; + assert (isequal (A, B)) + A(2:3, []) = 42; + assert (isequal (A, B)) + A([], 2:3) = 42; + assert (isequal (A, B)) + A(:, []) = 42; + assert (isequal (A, B)) + A([], :) = 42; + assert (isequal (A, B)) ***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = floor(A); - f2 = floor(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) + % Issue #1026 + a = sym(1:5); + a(1:3) = []; + assert (isequal (a, sym([4 5]))) ***** test - % round trip - y = sym('y'); - A = floor (d); - f = floor (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/ceil.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ceil.m -***** error ceil (sym(1), 2) -***** assert (isequaln (ceil (sym(nan)), sym(nan))) -***** shared x, d - d = 3/2; - x = sym('3/2'); + % Issue #1026 + B = eye(4); + A = sym(B); + A(1:2, :) = []; + B(1:2, :) = []; + assert (isequal (A, B)) +***** error + % TODO: do we care what error? + A = sym (magic (3)); + A(2:3, []) = [66; 66]; +***** error + A = sym (magic (3)); + A([]) = [66; 66]; +***** error + A = sym (magic (3)); + A([], 1) = [66; 66]; ***** test - f1 = ceil(x); - f2 = ceil(d); - assert( abs(double(f1) - f2) < 1e-15 ) + % Issue #966: empty indexing, empty RHS, A unchanged + B = magic(3); + A = sym(B); + A(1, []) = []; + assert (isequal (A, B)) + A([], 2) = []; + assert (isequal (A, B)) + A([], []) = []; + assert (isequal (A, B)) + A(2:3, []) = []; + assert (isequal (A, B)) + A([], 2:3) = []; + assert (isequal (A, B)) + A(:, []) = []; + assert (isequal (A, B)) + A([], :) = []; + assert (isequal (A, B)) ***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = ceil(A); - f2 = ceil(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) + % Issue 967 + B = [1 2; 3 4]; + A = sym(B); + A([]) = []; + assert (isequal (A, B)) ***** test - % round trip - y = sym('y'); - A = ceil (d); - f = ceil (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/rewrite.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/rewrite.m + % Issue #965 + a = sym(7); + a([]) = []; + assert (isequal (a, sym(7))) +***** test + % Issue #965 + a = sym(7); + a([]) = 42; + assert (isequal (a, sym(7))) +***** error + % Issue #965 + a = sym(7); + a([]) = [42 42] ***** test + b = eye (3); + a = sym (b); + I = [2 3; 4 5]; + a(I) = -2*I; + b(I) = -2*I; + assert (isequal (a, sym (b))); + assert (size (a), [3 3]); +***** error syms x - assert (isequal (rewrite(x, 'exp'), x)) + A = [1 x; x 2]; + A(5) = x; ***** test - % empty - e = sym([]); - assert (isequal (rewrite(e, 'sin'), e)) + % 2D indexing with length in one dimension more than 2 + a = sym ([1 2; 3 4; 5 6]); + indices = [1 4; 2 5; 3 6]; + b = [10 11; 12 13; 14 15]; + a(indices) = b; + assert (isequal (a, sym (b))); ***** test - syms x - A = [exp(x) exp(2*x)]; - B = [sinh(x) + cosh(x) sinh(2*x) + cosh(2*x)]; - assert (isequal (rewrite(A, 'sin'), B)) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/cosh.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cosh.m -***** error cosh (sym(1), 2) -***** assert (isequaln (cosh (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); + A = sym ([0 0 0]); + indices = [false true false]; + A(indices) = 1; + assert (isequal (A, sym ([0 1 0]))); + A(indices) = []; + assert (isequal (A, sym ([0 0]))); + indices = [false false]; + A(indices) = []; + assert (isequal (A, sym ([0 0]))); +***** shared a, b + a = [1 2 3 5; 4 5 6 9; 7 5 3 2]; + b = sym (a); ***** test - f1 = cosh(x); - f2 = cosh(d); - assert( abs(double(f1) - f2) < 1e-15 ) + A = a; B = b; + A(true) = 0; + B(true) = 0; + assert (isequal (A, B)) ***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = cosh(A); - f2 = cosh(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) + A = a; B = b; + A(false) = 0; + B(false) = 0; + assert (isequal (A, B)) ***** test - % round trip - y = sym('y'); - A = cosh (d); - f = cosh (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/cos.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cos.m -***** error cos (sym(1), 2) -***** assert (isequaln (cos (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); + c = [false true]; + A = a; B = b; + A(c) = 0; B(c) = 0; + assert (isequal (A, B)) + d = c | true; + A(d) = 1; B(d) = 1; + assert (isequal (A, B)) + d = c & false; + A(d) = 2; B(d) = 2; + assert (isequal (A, B)) ***** test - f1 = cos(x); - f2 = cos(d); - assert( abs(double(f1) - f2) < 1e-15 ) + c = [false true false true; true false true false; false true false true]; + A = a; B = b; + A(c) = 0; B(c) = 0; + assert (isequal (A, B)) + d = c | true; + A(d) = 1; B(d) = 1; + assert (isequal (A, B)) + d = c & false; + A(d) = 2; B(d) = 2; + assert (isequal (A, B)) ***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = cos(A); - f2 = cos(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) + c = [false true false true false]; + A = a; B = b; + A(c) = 0; B(c) = 0; + assert (isequal (A, B)) + d = c | true; + A(d) = 1; B(d) = 1; + assert (isequal (A, B)) + d = c & false; + A(d) = 2; B(d) = 2; + assert (isequal (A, B)) ***** test - % round trip - y = sym('y'); - A = cos (d); - f = cos (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/acoth.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/acoth.m -***** error acoth (sym(1), 2) -***** assert (isequaln (acoth (sym(nan)), sym(nan))) -***** shared x, d - d = 2; - x = sym('2'); + c = [false; true; false; true; false]; + A = a; B = b; + A(c) = 0; B(c) = 0; + assert (isequal (A, B)) + d = c | true; + A(d) = 1; B(d) = 1; + assert (isequal (A, B)) + d = c & false; + A(d) = 2; B(d) = 2; + assert (isequal (A, B)) ***** test - f1 = acoth(x); - f2 = acoth(d); - assert( abs(double(f1) - f2) < 1e-15 ) + c = [false true; false true; true false]; + A = a; B = b; + A(c) = 0; B(c) = 0; + assert (isequal (A, B)) + d = c | true; + A(d) = 1; B(d) = 1; + assert (isequal (A, B)) + d = c & false; + A(d) = 2; B(d) = 2; + assert (isequal (A, B)) +77 tests, 77 passed, 0 known failure, 0 skipped +[inst/@sym/has.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/has.m +***** shared A, x, y + syms x y + A = [sym(pi) 2*sym(pi); x*y x+y]; +***** assert (isequal (has(A, x), [false false; true true])); +***** assert (isequal (has(A, x+y), [false false; false true])); +***** assert (isequal (has(A, 2), [false true; false false])); +***** assert (isequal (has(A, sym(pi)), [true true; false false])); +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/ismatrix.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ismatrix.m +***** assert(ismatrix(sym('x'))) +***** assert(ismatrix(sym([1 2 3]))) +***** assert(ismatrix(sym([1; 2]))) +***** assert(ismatrix(sym([1 2; 3 4]))) +***** assert(ismatrix(sym([]))) +***** assert(ismatrix(sym(ones(1,0)))) +***** assert(ismatrix(sym(ones(0,3)))) +7 tests, 7 passed, 0 known failure, 0 skipped +[inst/@sym/atand.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/atand.m +***** error atand (sym(1), 2) +***** assert (isequaln (atand (sym(nan)), sym(nan))) ***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = acoth(A); - f2 = acoth(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) + f1 = atand (sym(1)/2); + f2 = atand (1/2); + assert (double (f1), f2, -eps) ***** test - % round trip - y = sym('y'); - A = acoth (d); - f = acoth (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/inv.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/inv.m + D = [1 2; 3 4]/4; + A = sym([1 2; 3 4])/4; + f1 = atand (A); + f2 = atand (D); + assert (double (f1), f2, -eps) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/int.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/int.m +***** shared x,y,a + syms x y a +***** assert(logical(int(cos(x)) - sin(x) == 0)) +***** assert(logical(int(cos(x),x) - sin(x) == 0)) +***** assert(logical(int(cos(x),x,0,1) - sin(sym(1)) == 0)) ***** test - % scalar + %% limits might be syms + assert( isequal (int(cos(x),x,sym(0),sym(1)), sin(sym(1)))) + assert( isequal (int(cos(x),x,0,a), sin(a))) +***** test + %% other variables present + assert( isequal (int(y*cos(x),x), y*sin(x))) +***** test + %% limits as array + assert( isequal (int(cos(x),x,[0 1]), sin(sym(1)))) + assert( isequal (int(cos(x),x,sym([0 1])), sin(sym(1)))) + assert( isequal (int(cos(x),x,[0 a]), sin(a))) +***** test + %% no x given + assert( isequal (int(cos(x),[0 1]), sin(sym(1)))) + assert( isequal (int(cos(x),sym([0 1])), sin(sym(1)))) + assert( isequal (int(cos(x),[0 a]), sin(a))) + assert( isequal (int(cos(x),0,a), sin(a))) +***** test + %% integration of const + assert( isequal (int(sym(2),y), 2*y)) + assert( isequal (int(sym(2)), 2*x)) + assert( isequal (int(sym(2),[0 a]), 2*a)) + assert( isequal (int(sym(2),0,a), 2*a)) +***** test + % componentwise int of array + A = [x x*x]; + assert (isequal (int(A, x), [x^2/2 x^3/3])) +***** test + % NonElementaryIntegral bug + % https://savannah.gnu.org/bugs/index.php?46831 + f = int(exp(exp(x))); + f = f + 2; + g = diff(f); + assert (isequal (g, exp(exp(x)))) +10 tests, 10 passed, 0 known failure, 0 skipped +[inst/@sym/solve.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/solve.m +***** test + % Simple, single variable, single solution syms x - assert (isequal (inv(x), 1/x)) + d = solve(10*x == 50); + assert (isequal (d, 5)) ***** test - % diagonal + % Single variable, multiple solutions syms x - A = [sym(1) 0; 0 x]; - B = [sym(1) 0; 0 1/x]; - assert (isequal (inv(A), B)) + d = solve(x^2 == 4); + assert (length(d) == 2); + assert (isequal (d, [2; -2]) || isequal (d, [-2; 2])) +***** shared x,y,eq + syms x y + eq = 10*x == 20*y; ***** test - % 2x2 inverse - A = [1 2; 3 4]; - assert (max (max (abs (double (inv (sym (A))) - inv(A)))) <= 3*eps) -***** error - syms a; - A = [a a; a a]; - inv(A) -***** error - syms a; - A = [a a]; - inv(A) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/laplacian.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/laplacian.m -***** shared x,y,z - syms x y z + d = solve(eq, x); + assert (isequal (d, 2*y)) ***** test - % 1D - f = x^2; - g = diff(f,x,x); - assert (isequal (laplacian(f), g)) - assert (isequal (laplacian(f,{x}), g)) - assert (isequal (laplacian(f,[x]), g)) - assert (isequal (laplacian(f,x), g)) + d = solve(eq, y); + assert (isequal (d, x/2)) ***** test - % const - f = sym(1); - g = sym(0); - assert (isequal (laplacian(f), g)) - assert (isequal (laplacian(f,x), g)) - f = sym('c'); - assert (isequal (laplacian(f,x), g)) + d = solve(eq); + assert (isequal (d, 2*y)) +***** shared x,y + syms x y ***** test - % double const - f = 1; - g = sym(0); - assert (isequal (laplacian(f,x), g)) + d = solve(2*x - 3*y == 0, x + y == 1); + assert (isequal (d.x, sym(3)/5) && isequal(d.y, sym(2)/5)) ***** test - % 1D fcn in 2d/3d - f = sin(2*y); - g = -4*f; - assert (isequal (laplacian(f), g)) - assert (isequal (laplacian(f, {x,y}), g)) - assert (isequal (laplacian(f, {x,y,z}), g)) + d = solve(2*x - 3*y == 0, x + y == 1, x, y); + assert (isequal (d.x, sym(3)/5) && isequal(d.y, sym(2)/5)) ***** test - % 2d fcn in 2d/3d - f = sin(exp(x)*y); - g = diff(f,x,x) + diff(f,y,y); - assert (isequal (laplacian(f), g)) - assert (isequal (laplacian(f, {x,y}), g)) + % Multiple solutions, multiple variables + d = solve(x^2 == 4, x + y == 1); + assert (length(d) == 2); + % FIXME: SMT has d.x gives vector and d.y giving vector, what is + % more intuitive? + for i = 1:2 + assert (isequal (d{i}.x + d{i}.y, 1)) + assert (isequal ((d{i}.x)^2, 4)) + end ***** test - % 2d fcn in 2d/3d - f = sin(exp(x)*y+sinh(z)); - gr2 = gradient(f, {x,y}); - divgr2 = divergence(gr2, {x,y}); - l2 = laplacian(f,{x,y}); - gr3 = gradient(f, {x,y,z}); - divgr3 = divergence(gr3, {x,y,z}); - l3 = laplacian(f,{x,y,z}); - assert (isAlways (l2 == divgr2)) - assert (isAlways (l3 == divgr3)) -***** error laplacian(sym('x'), sym('x'), 42) -***** error laplacian([sym('x'), sym('x')]) -8 tests, 8 passed, 0 known failure, 0 skipped -[inst/@sym/fortran.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/fortran.m -***** shared x,y,z + % No solutions syms x y z + d = solve(x == y, z); + assert (isempty (d)); ***** test - % basic test - f = x*sin(y) + abs(z); - source = fortran(f); - expected = ' x*sin(y) + abs(z)'; - s1 = strrep (expected, 'abs', 'Abs'); - assert (strcmp (source, expected) || strcmp (source, s1)) -***** test - % output test - f = x*sin(y) + abs(z); - [F,H] = fortran(f, 'file', '', 'show_header', false); - expected_h_code = sprintf('\ninterface\nREAL*8 function myfun(x, y, z)\nimplicit none\nREAL*8, intent(in) :: x\nREAL*8, intent(in) :: y\nREAL*8, intent(in) :: z\nend function\nend interface\n\n'); - expected_f_code = sprintf('\nREAL*8 function myfun(x, y, z)\nimplicit none\nREAL*8, intent(in) :: x\nREAL*8, intent(in) :: y\nREAL*8, intent(in) :: z\n\nmyfun = x*sin(y) + abs(z)\n\nend function\n'); - assert(strcmp(F.name, 'file.f90')) - assert(strcmp(H.name, 'file.h')) - %disp(expected_f_code); disp(F.code) - s1 = strrep (expected_f_code, 'abs', 'Abs'); - s2 = strrep (expected_f_code, sprintf ('\n'), sprintf ('\r\n')); - s3 = strrep (s2, 'abs', 'Abs'); - s4 = strrep (expected_h_code, sprintf ('\n'), sprintf ('\r\n')); - assert (strcmp (F.code, expected_f_code) || strcmp (F.code, s1) || strcmp (F.code, s2) || strcmp (F.code, s3)) - assert (strcmp (H.code, expected_h_code) || strcmp (H.code, s4)) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/isvector.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isvector.m -***** assert(isvector(sym('x'))) -***** assert(isvector(sym([1 2 3]))) -***** assert(isvector(sym([1; 2]))) -***** assert(~isvector(sym([1 2; 3 4]))) -***** assert(~isvector(sym([]))) -***** assert(isvector(sym(ones(1,0)))) -***** assert(~isvector(sym(ones(0,3)))) -7 tests, 7 passed, 0 known failure, 0 skipped -[inst/@sym/any.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/any.m + % Multiple outputs with single solution + [X, Y] = solve(2*x + y == 5, x + y == 3); + assert (isequal (X, 2)) + assert (isequal (Y, 1)) ***** test - % matrix - a = [0 0; 1 0]; - s = sym(a); - assert (isequal (any (s), any (a))) - assert (isequal (any (s,1), any (a,1))) - assert (isequal (any (s,2), any (a,2))) + % system: vector of equations, vector of vars + [X, Y] = solve([2*x + y == 5, x + y == 3], [x y]); + assert (isequal (X, 2)) + assert (isequal (Y, 1)) ***** test - % vector - a = [0 1 0]; - s = sym(a); - assert (isequal (any (s), any (a))) - assert (isequal (any (s,1), any (a,1))) - assert (isequal (any (s,2), any (a,2))) + % system: vector of equations, individual vars + [X, Y] = solve([2*x + y == 5, x + y == 3], x, y); + assert (isequal (X, 2)) + assert (isequal (Y, 1)) ***** test - % should fail on symbols - syms x - s = [0 1 x]; - try - any (s) - waserr = false; - catch - waserr = true; - end - assert (waserr) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/cosd.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cosd.m -***** error cosd (sym(1), 2) -***** assert (isequaln (cosd (sym(nan)), sym(nan))) + % system: individual equations, vector of vars + [X, Y] = solve(2*x + y == 5, x + y == 3, [x y]); + assert (isequal (X, 2)) + assert (isequal (Y, 1)) ***** test - f1 = cosd (sym(1)); - f2 = cosd (1); - assert (double (f1), f2, -eps) + % Multiple outputs with multiple solns + [X, Y] = solve(x*x == 4, x == 2*y); + assert ((isequal (X, [2; -2]) && isequal (Y, [1; -1])) || ... + (isequal (X, [-2; 2]) && isequal (Y, [-1; 1]))) ***** test - D = [10 30; 110 -45]; - A = sym(D); - f1 = cosd (A); - f2 = cosd (D); - assert (double (f1), f2, -4*eps) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/diag.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/diag.m + % Multiple outputs with multiple solns, specify vars + [X, Y] = solve(x*x == 4, x == 2*y, x, y); + assert ((isequal (X, [2; -2]) && isequal (Y, [1; -1])) || ... + (isequal (X, [-2; 2]) && isequal (Y, [-1; 1]))) +***** error + % mult outputs not allowed for scalar equation, even with mult soln (?) + [s1, s2] = solve(x^2 == 4, x); ***** test - % scalar - syms x - assert (isequal (diag(x), x)) + % overdetermined + X = solve(2*x - 10 == 0, 3*x - 15 == 0, x); + assert (isequal (X, sym(5))) ***** test - % row,col vec input - syms x - r = [1 x 2]; - c = [sym(1); x]; - assert (isequal (diag(diag(c)), c)) - assert (isequal (diag(c), [sym(1) 0; 0 x])) - assert (isequal (diag(diag(r)), r.')) - assert (isequal (diag(r), [sym(1) 0 0; 0 x 0; sym(0) 0 2])) + a = solve(2*x >= 10, 10*x <= 50); + assert (isequal( a, x==sym(5))) ***** test - % create matrix, kth diag - syms x - r = [1 x]; - z = sym(0); - assert (isequal (diag (x, 0), x)) - assert (isequal (diag (x, 1), [z x; z z])) - assert (isequal (diag (x, -1), [z z; x z])) - assert (isequal (diag (x, 2), [z z x; z z z; z z z])) - assert (isequal (diag (r, 1), [z 1 z; z z x; z z z])) + A = solve([2*x == 4*y, 2 == 3], x); + assert (isempty (A)) ***** test - % extract kth diag - A = sym([1 2 3; 4 5 6]); - assert (isequal (diag(A), sym([1; 5]))) - assert (isequal (diag(A, 0), sym([1; 5]))) - assert (isequal (diag(A, 1), sym([2; 6]))) - assert (isequal (diag(A, 2), sym(3))) - assert (isequal (diag(A, -1), sym(4))) - assert (isempty (diag(A, -2))) - assert (isempty (diag(A, 3))) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/tril.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/tril.m + % Issue #850 + A = solve (sym(pi)^2*x + y == 0); + assert (isequal (A, -y/sym(pi)^2)) ***** test - syms x - assert (isequal (tril(x), x)) + % https://github.com/sympy/sympy/issues/14632 + A = solve([2*x == 4*y, sym(2) == 2], x); + assert (isequal (A, 2*y)) ***** test - % with symbols - syms x - A = [x 2*x; 3*x 4*x]; - assert (isequal (tril(A), [x 0; 3*x 4*x])) + % https://github.com/sympy/sympy/issues/14632 + A = solve([2*x^2 == 32*y^2, sym(2) == 2], x); + B = solve([2*x^2 == 32*y^2], x); + assert (isequal (A, B) || isequal (A, flip (B))) ***** test - % diagonal shifts - B = round(10*rand(3,4)); - A = sym(B); - assert (isequal (tril(A), tril(B))) - assert (isequal (tril(A,0), tril(B,0))) - assert (isequal (tril(A,1), tril(B,1))) - assert (isequal (tril(A,-1), tril(B,-1))) + A = solve ([x+1 0], x); + assert (isequal (A, sym (-1))) ***** test - % double array pass through - B = round(10*rand(3,4)); - assert (isequal (tril(B,sym(1)), tril(B,1))) - assert (isa (tril(B,sym(1)), 'double')) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/disp.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/disp.m + A = solve (x + 1, x); + assert (isequal (A, sym (-1))) + A = solve (x, x); + assert (isequal (A, sym (0))) +24 tests, 24 passed, 0 known failure, 0 skipped +[inst/@sym/coeffs.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/coeffs.m +***** error coeffs (sym(1), 2, 3, 4) +***** error coeffs (sym(1), 2, 'al') +***** error coeffs (sym(1), 'al') ***** test + % simple syms x - s = disp(sin(x)); - assert(strcmp(s, sprintf(' sin(x)\n'))) + [c, t] = coeffs(6*x*x + 27); + assert (isequal (c, [6 27])) + assert (isequal (t, [x*x 1])) ***** test + % specify a variable syms x - s = disp(sin(x/2), 'flat'); - assert(strcmp(s, sprintf(' sin(x/2)\n'))) + [c, t] = coeffs(6*x*x + 27, x); + assert (isequal (c, [6 27])) + assert (isequal (t, [x*x 1])) ***** test - % Examples of 2x0 and 0x2 empty matrices: - a = sym([1 2; 3 4]); - b2x0 = a([true true], [false false]); - b0x2 = a([false false], [true true]); - assert (isequal (size (b2x0), [2 0])) - assert (isequal (size (b0x2), [0 2])) - s = disp(b2x0); - assert(strcmp(s, sprintf(' []\n'))) - s = disp(b0x2); - assert(strcmp(s, sprintf(' []\n'))) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/symreplace.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/symreplace.m + % specify another variable + syms x y + [c, t] = coeffs(6*x + 27, y); + assert (isequal (c, 6*x + 27)) + assert (isequal (t, 1)) ***** test - % start with assumptions on x then remove them - syms x positive - f = x*10; - symreplace(x, sym('x')) - assert(isempty(assumptions(x))) + % weird SMT order + syms x + a1 = [27 6]; + a2 = [6 27]; + c = coeffs(6*x*x + 27); + assert (isequal (c, a1)) + coeffs(6*x*x + 27); + assert (isequal (ans, a1)) + [c, t] = coeffs(6*x*x + 27); + assert (isequal (c, a2)) ***** test - % replace x with y + % no weird order with "all" syms x - f = x*10; - symreplace(x, sym('y')) - assert( isequal (f, 10*sym('y'))) + c = coeffs(6*x*x + 27, 'all'); + assert (isequal (c, [6 0 27])) ***** test - % gets inside cells + % "all" syms x - f = {x 1 2 {3 4*x}}; - symreplace(x, sym('y')) - syms y - assert( isequal (f{1}, y)) - assert( isequal (f{4}{2}, 4*y)) + [c, t] = coeffs(6*x*x + 27, 'all'); + assert (isequal (c, [6 0 27])) + assert (isequal (t, [x^2 x 1])) ***** test - % gets inside structs/cells + % "All" syms x - my.foo = {x 1 2 {3 4*x}}; - my.bar = x; - g = {'ride' my 'motor' 'sicle'}; - symreplace(x, sym('y')) - syms y - f = g{2}; - assert( isequal (f.foo{1}, y)) - assert( isequal (f.foo{4}{2}, 4*y)) - assert( isequal (f.bar, y)) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/heaviside.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/heaviside.m -***** error heaviside (sym(1), 2, 3) -***** assert (isequal (heaviside (sym(1)), sym(1))) -***** assert (isequal (heaviside (-sym(1)), sym(0))) -***** assert (double (heaviside (1)), heaviside (1)) + [c, t] = coeffs(6*x, 'All'); + assert (isequal (c, [6 0])) + assert (isequal (t, [x 1])) ***** test - D = [1 -1; -10 20]; - A = sym(D); - assert (double (heaviside (A)), heaviside (D)) + % multivariable array + syms x y + [c, t] = coeffs(6*x*x + 27*y*x + 36, [x y]); + a = [6 27 36]; + s = [x^2 x*y 1]; + assert (isequal (c, a)) + assert (isequal (t, s)) + % with list + [c, t] = coeffs(6*x*x + 27*y*x + 36, {x y}); + assert (isequal (c, a)) + assert (isequal (t, s)) ***** test - H0 = sym([1 -2 0; 3 0 pi]); - A = heaviside (sym(0), H0); - assert (isequal (A, H0)) + % other symbols treated as part of coeffs + syms x y + [c, t] = coeffs(6*x*x + 27*y*x + 36, x); + a = [6 27*y 36]; + s = [x^2 x 1]; + assert (isequal (c, a)) + assert (isequal (t, s)) +***** error + % TODO: multivariate all not working (https://github.com/gnu-octave/symbolic/issues/720) + syms x y + [c, t] = coeffs(6*x^2 + 7*y + 19, [x y], 'all'); ***** test - A = heaviside ([-1 0 1], sym(1)/2); - assert (isequal (A, [0 sym(1)/2 1])) + % empty same as not specifying; maybe not SMT compatible: + % https://github.com/gnu-octave/symbolic/pull/708#discussion_r94292831 + syms x y + [c, t] = coeffs(6*x*x + 27*y*x + 36, {}); + a = [6 27 36]; + assert (isequal (c, a)) + [c, t] = coeffs(6*x*x + 27*y*x + 36); + assert (isequal (c, a)) ***** test - A = heaviside ([-1 0 1], sym(1)/2); - assert (isequal (A, [0 sym(1)/2 1])) -***** assert (isequaln (heaviside (sym(nan)), sym(nan))) + % no input defaults to all symbols (not symvar to get x) + syms x y + [c, t] = coeffs(6*x*x + 27*y*x + 36); + assert (isequal (c, [6 27 36])) ***** test - assert (isequaln (heaviside (sym(nan), sym(nan)), sym(nan))) - assert (isequaln (heaviside (0, sym(nan)), sym(nan))) - assert (isequaln (heaviside (2, sym(nan)), sym(1))) - assert (isequaln (heaviside (-2, sym(nan)), sym(0))) + % non sym input + syms x + assert (isequal (coeffs(6, x), sym(6))) ***** test - % round trip + % constant input without x + assert (isequal (coeffs(sym(6)), sym(6))) +***** test + % constant input without x + assert (isequal (coeffs (sym(6), {}), sym(6))) + % irrational coefficients syms x - A = heaviside (1); - f = heaviside (x); - h = function_handle (f); - B = h (1); - assert (A, B, -eps) + f = x^2 + sqrt(sym(2))*x; + [c1, t1] = coeffs (f); + [c2, t2] = coeffs (f, x); + assert (isequal (c1, c2)) + assert (isequal (t1, t2)) +18 tests, 18 passed, 0 known failure, 0 skipped +[inst/@sym/hypot.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/hypot.m +***** assert (isequal (hypot (sym(3), 4), sym(5))) ***** test - % round trip - syms x h0 - f = heaviside (x, h0); - h = function_handle (f, 'vars', {x h0}); - A = heaviside (1, 1/2); - B = h (1, 1/2); - assert (A, B, -eps) - A = heaviside (0, 1/2); - B = h (0, 1/2); + % compare to @double (note Matlab hypot only takes 2 inputs) + A = hypot (hypot ([1 2 3], [4 5 6]), [7 8 9]); + B = double (hypot (sym([1 2 3]), [4 5 6], [7 8 9])); assert (A, B, -eps) -12 tests, 12 passed, 0 known failure, 0 skipped -[inst/@sym/logspace.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/logspace.m -***** test - % default argument for N - A = logspace(0, 2); - assert (length (A) == 50); ***** test - % special case: pi as end pt - A = logspace(-sym(3), sym(pi), 3); - assert (isequal (A(end), sym(pi))) + % compare to @double, with complex + A = hypot ([1+2i 3+4i], [1 3+1i]); + B = double (hypot (sym([1+2i 3+4i]), [1 3+1i])); + assert (A, B, -eps) ***** test - A = logspace(-sym(4), 0, 3); - B = [sym(1)/10000 sym(1)/100 sym(1)]; + % matrices + x = sym([1 -2; 0 3]); + y = sym([0 0; 8 4]); + A = hypot (x, y); + B = sym([1 2; 8 5]); assert (isequal (A, B)) -***** test - % vpa support, might need recent sympy for sympy issue #10063 - n = 32; - A = logspace(-vpa(1,n), 0, 3); - B = [10^(-vpa(1,n)) 10^(-vpa(sym(1)/2,n)) vpa(1,n)]; - assert (all (A == B)) - assert (max(abs(double(A) - logspace(-1, 0, 3))) < 1e-15) 4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/horzcat.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/horzcat.m +[inst/@sym/isconstant.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isconstant.m ***** test - % basic syms x - A = [x x]; - B = horzcat(x, x); - C = horzcat(x, x, x); - assert (isa (A, 'sym')) - assert (isa (B, 'sym')) - assert (isa (C, 'sym')) - assert (isequal (size(A), [1 2])) - assert (isequal (size(B), [1 2])) - assert (isequal (size(C), [1 3])) + A = [x 2 3]; + B = [false true true]; + assert (isequal (isconstant (A), B)) ***** test - % basic, part 2 syms x - A = [x 1]; - B = [1 x]; - C = [1 2 x]; - assert (isa (A, 'sym')) - assert (isa (B, 'sym')) - assert (isa (C, 'sym')) - assert (isequal (size(A), [1 2])) - assert (isequal (size(B), [1 2])) - assert (isequal (size(C), [1 3])) -***** test - % row vectors - a = [sym(1) 2]; - b = [sym(3) 4]; - assert (isequal ( [a b] , [1 2 3 4] )) - assert (isequal ( [a 3 4] , [1 2 3 4] )) - assert (isequal ( [3 4 a] , [3 4 1 2] )) - assert (isequal ( [a [3 4]] , [1 2 3 4] )) - assert (isequal ( [a sym(3) 4] , [1 2 3 4] )) - assert (isequal ( [a [sym(3) 4]] , [1 2 3 4] )) -***** test - % col vectors - a = [sym(1); 2]; - b = [sym(3); 4]; - assert (isequal ( [a b] , [1 3; 2 4] )) - assert (isequal ( [a b a] , [1 3 1; 2 4 2] )) -***** test - % empty vectors - v = sym(1); - a = [v []]; - assert (isequal (a, v)) - a = [[] v []]; - assert (isequal (a, v)) - a = [v [] []]; - assert (isequal (a, v)) -***** test - % more empty vectors - v = [sym(1) sym(2)]; - q = sym(ones(1, 0)); - assert (isequal ([v q], v)) -***** error - v = [sym(1) sym(2)]; - q = sym(ones(3, 0)); - w = horzcat(v, q); -***** test - % issue #700 - A = sym ([1 2]); - B = simplify (A); - assert (isequal ([B A], [A B])) -8 tests, 8 passed, 0 known failure, 0 skipped + A = [x 2; 3 x]; + B = [false true; true false]; + assert (isequal (isconstant (A), B)) +2 tests, 2 passed, 0 known failure, 0 skipped [inst/@sym/fresnels.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/fresnels.m ***** error fresnels (sym(1), 2) @@ -5735,719 +8613,871 @@ B = fresnels (1.1); assert (A, B) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/curl.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/curl.m -***** error curl([sym(1) 2 3], 42, 42) -***** shared x,y,z - syms x y z -***** test - % double const - f = [1 2 3]; - g = [sym(0); 0; 0]; - assert (isequal (curl(f, [x y z]), g)) - % should fail, calls @double: curl(f, {x y z}), g)) +[inst/@sym/sym2poly.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sym2poly.m +***** shared x,y,a,b,c + syms x y a b c +***** assert (isequal (sym2poly (x^2 + 3*x - 4), [1 3 -4])) +***** assert (isequal (sym2poly (x^6 - x^3), [1 0 0 -1 0 0 0])) +***** assert (isequal (sym2poly (x^2 + 3*x - 4, x), [1 3 -4])) +***** assert (norm (sym2poly (pi*x^2 + exp(sym(1))) - [pi 0 exp(1)]) < 10*eps) +***** assert (isa (sym2poly (x^2 + 3*x - 4), 'double')) +***** assert (isa (sym2poly (x^2 + 3*x - 4, x), 'sym')) +***** assert (isequal (sym2poly (x^2+y*x, x), [sym(1) y sym(0)])) +***** assert (isequal (sym2poly (x^2+y*x, y), [x x^2])) +***** assert (isequal (sym2poly (poly2sym ([a b c], x), x), [a b c])) +***** assert (isequal (poly2sym (sym2poly(a*x^2 + c, x), x), a*x^2 + c)) +***** assert (isequal (sym2poly (poly2sym ([1 2 3])), [1 2 3])) +***** error + % too many symbols for single-input + p = a*x^2 + 2; + c = sym2poly (p); +***** assert (isequal (sym2poly (sym(5)), sym(5))) +13 tests, 13 passed, 0 known failure, 0 skipped +[inst/@sym/cbrt.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cbrt.m +***** error cbrt (sym(1), 2) +***** assert (isequaln (cbrt (sym(nan)), sym(nan))) +***** shared x, d + d = 2; + x = sym('2'); ***** test - % div curl always 0 - v = [exp(x); x*y; sin(z)]; - g = curl(v); - a = divergence(g, [x y z]); - assert (isAlways (a == sym(0))) - assert (isa (a, 'sym')) - g = curl(v, [x y z]); - a = divergence(g, [x y z]); - assert (isAlways (a == sym(0))) - assert (isa (a, 'sym')) + f1 = cbrt(x); + f2 = 1.2599210498948731647; + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - % div curl always 0 - v = [exp(x); erfc(x*y); sin(exp(x)*y+sinh(z))]; - g = curl(v, [x y z]); - a = divergence(g, [x y z]); - assert (isAlways (a == sym(0))) - assert (isa (a, 'sym')) + D = [d d; d d]; + A = [x x; x x]; + f1 = cbrt(A); + f2 = 1.2599210498948731647; + f2 = [f2 f2; f2 f2]; + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test - % curl grad is vec zero - f = sin(exp(x)*y+sinh(z)); - g = curl(gradient(f, [x,y,z])); - assert (isequal (g, sym([0;0;0]))) + % round trip + y = sym('y'); + if (exist ('OCTAVE_VERSION', 'builtin')) + A = cbrt (d); + else + % Issue #742 + A = d^(1/3); + end + f = cbrt (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/isrow.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isrow.m +***** assert (isrow (sym ([1]))) +***** assert (isrow (sym ([1 2 3]))) +***** assert (~isrow (sym ([]))) +***** assert (~isrow (sym ([1 2 3]'))) +***** assert (~isrow (sym ([1 2; 3 4]))) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/unique.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/unique.m ***** test - % 2d fcn in 2d/3d - u = sin(exp(x)*y); - v = x^2*y^3; - vorticity2d = diff(v,x) - diff(u,y); - omega = curl([u; v; 0], [x y z]); - assert (isequal (omega, [0; 0; vorticity2d])) -***** error <3D vector> curl([sym(1) 2 3 4]) -***** error curl([sym(1) 2 3], {sym('x') sym('y') sym('z') sym('t')}) -8 tests, 8 passed, 0 known failure, 0 skipped -[inst/@sym/asind.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/asind.m -***** error asind (sym(1), 2) -***** assert (isequaln (asind (sym(nan)), sym(nan))) + A = sym([1 2 3 3 5 3 2 6 5]); + B = sym([1 2 3 5 6]); + assert (isequal (unique(A), B)) ***** test - f1 = asind (sym(1)/2); - f2 = asind (1/2); - assert (double (f1), f2, -eps) + syms x y + A = [1 2 3 3 4 5 5 6 7 7 x x y y]; + B = [1 2 3 4 5 6 7 x y]; + assert (isequal (unique(A), B)) ***** test - D = [1 2; 3 4]/4; - A = sym([1 2; 3 4])/4; - f1 = asind (A); - f2 = asind (D); - assert (double (f1), f2, -eps) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/laguerreL.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/laguerreL.m -***** shared x syms x -***** assert (isequal (laguerreL(0, x), sym(1))) -***** assert (isequal (laguerreL(1, x), 1-x)) -***** assert (isequal (laguerreL(2, x), x^2/2 - 2*x + 1)) -***** error laguerreL(x) -***** error laguerreL(1, 2, x, 3) -***** shared + assert (isequal (unique(x), x)) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/pretty.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/pretty.m ***** test + % simple syms x - assert (isequal (laguerreL (-3, x), exp(x)*(x^2/2 + 2*x + 1))) -***** test - syms x n - L = laguerreL([2 n], x); - expected = [laguerreL(2, x) laguerreL(n, x)]; - assert (isequal (L, expected)) -***** test - syms x y - L = laguerreL([1; 2], [x; y]); - expected = [laguerreL(1, x); laguerreL(2, y)]; - assert (isequal (L, expected)) + s1 = pretty(sin(x)); + s2 = sprintf(' sin(x)\n'); + assert (strcmp (s1, s2)) ***** test - syms x n - assert (isequal (laguerreL(n, 0, x), laguerreL(n, x))) -***** shared x, y, n - syms x y n -***** assert (isequal (laguerreL([1 n], 0, x), laguerreL([1 n], x))) + % force ascii + syms x + s1 = pretty(sin(x/2), 'ascii'); + s2 = sprintf(' /x\\\n sin|-|\n \\2/\n'); + swin = strrep(s1, sprintf('\r\n'), sprintf('\n')); + assert (strcmp (s1, s2) || strcmp (swin, s2)) ***** test - L = laguerreL([1; n], [pi; 0], [x; y]); - expected = [laguerreL(1, pi, x); laguerreL(n, 0, y)]; - assert (isequal (L, expected)) + % force unicode + syms x + s1 = pretty(sin(x/2), 'unicode'); + s2 = sprintf(' ⎛x⎞\n sin⎜─⎟\n ⎝2⎠\n'); + swin = strrep(s1, sprintf('\r\n'), sprintf('\n')); + assert (strcmp (s1, s2) || strcmp (swin, s2)) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/psi.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/psi.m +***** assert (isequal (psi (sym (1)), -eulergamma)) +***** assert (isequal (psi (1, sym (1)), sym (pi)^2/6)) +***** assert (isinf (psi (sym ('inf')))) ***** test - L = laguerreL([1 n], [pi 0], x); - expected = [laguerreL(1, pi, x) laguerreL(n, 0, x)]; - assert (isequal (L, expected)) + % compare to Maple: evalf(Psi(-101/100)); + maple = vpa ('100.3963127058453949545769053445198842332424', 40); + us = vpa (psi (sym (-101)/100), 40); + assert (abs(double(maple-us)) < 1e-39) ***** test - L = laguerreL([1 n], pi, [x y]); - expected = [laguerreL(1, pi, x) laguerreL(n, pi, y)]; - assert (isequal (L, expected)) + % compare to Maple: evalf(Psi(1, 3*I-2)); + maple = vpa ('-0.1651414829219882371561038184133243839778799', 40) - ... + vpa ('0.1960040752985823275302034466611711263617296j', 40); + us = vpa (psi (1, sym (-2) + sym(3i)), 40); + assert (abs(double(maple-us)) < 1e-39) ***** test - L = laguerreL(1, [pi 0], [x y]); - expected = [laguerreL(1, pi, x) laguerreL(1, 0, y)]; - assert (isequal (L, expected)) + % should match @double/psi + if (exist ('psi','builtin')) + assert (psi (pi), double (psi (sym (pi))), -3*eps) + assert (psi (100), double (psi (sym (100))), -3*eps) + assert (psi (1e-3), double (psi (1/sym (1e3))), -3*eps) + if (exist ('OCTAVE_VERSION', 'builtin')) + % 2014a doesn't support negative or complex arguments + assert (psi (-1.5), double (psi (sym (-3)/2)), -3*eps) + assert (psi (-8.3), double (psi (sym (-83)/10)),-4*eps) + assert (psi (2i), double (psi (sym (2i))), -3*eps) + assert (psi (10i+3), double (psi (sym (10i)+3)), -3*eps) + end + end ***** test - L = laguerreL([1 n], pi, x); - expected = [laguerreL(1, pi, x) laguerreL(n, pi, x)]; - assert (isequal (L, expected)) + % @double/psi loses accuracy near the poles: note higher rel tol + if (exist ('psi','builtin')) + if (exist ('OCTAVE_VERSION', 'builtin')) + assert (psi (-1.1), double (psi (sym (-11)/10)), -6*eps) + assert (psi (-1.01), double (psi (sym (-101)/100)), -50*eps) + end + end ***** test - L = laguerreL(1, [pi 0], x); - expected = [laguerreL(1, pi, x) laguerreL(1, 0, x)]; - assert (isequal (L, expected)) + if (exist ('psi','builtin')) + assert (psi (1, pi), double (psi (1, sym (pi))), -3*eps) + assert (psi (1, 100), double (psi (1, sym (100))), -3*eps) + assert (psi (1, 1e-4), double (psi (1, 1/sym (1e4))), -3*eps) + end ***** test - L = laguerreL(1, pi, [x y]); - expected = [laguerreL(1, pi, x) laguerreL(1, pi, y)]; - assert (isequal (L, expected)) + if (exist ('psi','builtin')) + assert (psi (2, pi), double (psi (2, sym (pi))), -3*eps) + assert (psi (2, 1000), double (psi (2, sym (1000))), -3*eps) + assert (psi (2, 1e-4), double (psi (2, 1/sym (1e4))), -3*eps) + end ***** test % round trip - f = laguerreL (n, x); + if (exist ('psi','builtin')) + syms x + f = psi (x); h = function_handle (f); - A = h (1, 3.2); - B = laguerreL (1, 3.2); - assert (A, B) - A = h ([1 2], [3.3 4.4]); - B = laguerreL ([1 2], [3.3 4.4]); + A = h (1.1); + B = psi (1.1); assert (A, B) -***** error - % round trip - f = laguerreL (n, y, x); - h = function_handle (f); -19 tests, 19 passed, 0 known failure, 0 skipped -[inst/@sym/diff.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/diff.m -***** shared x,y,z - syms x y z -***** test - % basic - assert(logical( diff(sin(x)) - cos(x) == 0 )) - assert(logical( diff(sin(x),x) - cos(x) == 0 )) - assert(logical( diff(sin(x),x,x) + sin(x) == 0 )) -***** test - % these fail when doubles are not converted to sym - assert(logical( diff(sin(x),x,2) + sin(x) == 0 )) - assert(logical( diff(sym(1),x) == 0 )) - assert(logical( diff(1,x) == 0 )) - assert(logical( diff(pi,x) == 0 )) -***** test - % symbolic diff of const (w/o variable) fails in sympy, but we work around - assert (isequal (diff(sym(1)), sym(0))) -***** test - % nth symbolic diff of const - assert (isequal (diff(sym(1), 2), sym(0))) - assert (isequal (diff(sym(1), sym(1)), sym(0))) -***** test - % octave's vector difference still works - assert(isempty(diff(1))) - assert((diff([2 6]) == 4)) -***** test - % other forms - f = sin(x); - g = diff(f,x,2); - assert (isequal (diff(f,2), g)) - assert (isequal (diff(f,sym(2)), g)) - g = diff(f,x); - assert (isequal (diff(f), g)) - assert (isequal (diff(f,1), g)) -***** test - % old SMT supported (still does?) the 'n' before the 'x' - % we might remove this someday, no longer seems documented in SMT - f = sin(x); - g = diff(f,x,2); - assert (isequal (diff(f,2,x), g)) - assert (isequal (diff(f,sym(2),x), g)) - g = diff(f,x); - assert (isequal (diff(f,1,x), g)) -***** test - % matrix - A = [x sin(x); x*y 10]; - B = [1 cos(x); y 0]; - assert(isequal(diff(A,x),B)) -***** test - % bug: use symvar - a = x*y; - b = diff(a); - assert (isequal (b, y)) -***** test - % bug: symvar should be used on the matrix, not comp-by-comp - a = [x y x*x]; - b = diff(a); - assert (~isequal (b(2), 1)) - assert (isequal (b, [1 0 2*x])) - b = diff(a,1); - assert (~isequal (b(2), 1)) - assert (isequal (b, [1 0 2*x])) -10 tests, 10 passed, 0 known failure, 0 skipped -[inst/@sym/bernoulli.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/bernoulli.m -***** error bernoulli (sym(1), 2, 3) -***** assert (isequal (bernoulli (sym(8)), -sym(1)/30)) -***** assert (isequal (bernoulli (sym(9)), sym(0))) -***** test syms x - assert (isequal (bernoulli(3,x), x^3 - 3*x^2/2 + x/2)) -***** test - % two different definitions in literature - assert (isequal (abs (bernoulli (sym(1))), sym(1)/2)) -***** test - % we use B_1 = 1/2 - if (pycall_sympy__ ('return Version(spver) >= Version("1.12.dev")')) - assert (isequal (bernoulli (sym(1)), sym(1)/2)) end -***** test - m = sym([0 2; 8 888889]); - A = bernoulli (m); - B = [1 sym(1)/6; -sym(1)/30 0]; - assert (isequal (A, B)) -***** test - syms x - A = bernoulli ([0; 1], x); - B = [sym(1); x - sym(1)/2]; - assert (isequal (A, B)) -***** test - % round trip - syms n x - f = bernoulli (n, x); - h = function_handle (f, 'vars', [n x]); - A = h (2, 2.2); - B = bernoulli (2, 2.2); - assert (A, B) -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/expm.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/expm.m -***** test - % scalar - syms x - assert (isequal (expm(x), exp(x))) -***** test - % diagonal - A = [sym(1) 0; 0 sym(3)]; - B = [exp(sym(1)) 0; 0 exp(sym(3))]; - assert (isequal (expm(A), B)) -***** test - % diagonal w/ x - syms x positive - A = [sym(1) 0; 0 x+2]; - B = [exp(sym(1)) 0; 0 exp(x+2)]; - assert (isequal (expm(A), B)) -***** test - % non-diagonal - syms x positive - A = [sym(1) 2; 0 x+2]; - B = expm(A); - C = double(subs(B, x, 4)); - D = expm(double(subs(A, x, 4))); - assert (max (max (abs (C - D))) <= 1e-11) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/chol.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/chol.m -***** error chol (sym ([1 2; 3 4])); -***** error chol (sym ([1 2; 3 4; 5 6])); -***** test - A = chol(hilb(sym(2))); - B = [[1 0]; sym(1)/2 sqrt(sym(3))/6]; - assert( isequal( A, B )) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/sqrt.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sqrt.m -***** error sqrt (sym(1), 2) -***** assert (isequaln (sqrt (sym(nan)), sym(nan))) +10 tests, 10 passed, 0 known failure, 0 skipped +[inst/@sym/logint.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/logint.m +***** error logint (sym(1), 2) +***** xtest + assert (isequaln (logint (sym(nan)), sym(nan))) +!!!!! known failure +assert (isequaln (logint (sym (nan)), sym (nan))) failed ***** shared x, d - d = 1; - x = sym('1'); + d = 2; + x = sym('2'); ***** test - f1 = sqrt(x); - f2 = sqrt(d); + f1 = logint(x); + f2 = 1.045163780117492784845; assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = sqrt(A); - f2 = sqrt(D); + f1 = logint(A); + f2 = 1.045163780117492784845; + f2 = [f2 f2; f2 f2]; assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = sqrt (d); - f = sqrt (y); + A = logint (d); + f = logint (y); h = function_handle (f); B = h (d); assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/ezsurf.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ezsurf.m -***** error - syms u v t - ezsurf(u*v, 2*u*v, 3*v*t) -***** error - syms u v t - ezsurf(u*v, 2*u*v, u*v*t) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/ge.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ge.m -***** test - % simple - x = sym(1); y = sym(1); e = x >= y; - assert (logical (e)) - x = sym(1); y = sym(2); e = x >= y; - assert (~logical(e)) -***** test - % array -- array - syms x - a = sym([1 3 3 2*x]); - b = sym([2 x 3 10]); - e = a >= b; - assert (isa (e, 'sym')) - assert (~logical (e(1))) - assert (isa (e(2), 'sym')) - assert (isequal (e(2), 3 >= x)) - assert (logical (e(3))) - assert (isa (e(4), 'sym')) - assert (isequal (e(4), 2*x >= 10)) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/csch.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/csch.m -***** error csch (sym(1), 2) -***** assert (isequaln (csch (sym(nan)), sym(nan))) +5 tests, 4 passed, 1 known failure, 0 skipped +[inst/@sym/sinint.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sinint.m +***** error sinint (sym(1), 2) +***** xtest + assert (isequaln (sinint (sym(nan)), sym(nan))) +!!!!! known failure +assert (isequaln (sinint (sym (nan)), sym (nan))) failed ***** shared x, d d = 1; x = sym('1'); ***** test - f1 = csch(x); - f2 = csch(d); + f1 = sinint(x); + f2 = 0.9460830703671830149414; assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = csch(A); - f2 = csch(D); + f1 = sinint(A); + f2 = 0.9460830703671830149414; + f2 = [f2 f2; f2 f2]; assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = csch (d); - f = csch (y); + A = sinint (d); + f = sinint (y); h = function_handle (f); B = h (d); assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/jordan.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/jordan.m ***** test - % basic - A = sym ([2 1 0 0; 0 2 1 0; 0 0 3 0; 0 1 -1 3]); - [V, J] = jordan (A); - assert (isequal (inv (V) * A * V, J)); - assert (isequal (J, sym ([2 1 0 0; 0 2 0 0; 0 0 3 0; 0 0 0 3]))) - % the first 2 generalized eigenvectors form a cycle - assert (isequal ((A - J(1, 1) * eye (4)) * V(:, 1), zeros (4, 1))); - assert (isequal ((A - J(2, 2) * eye (4)) * V(:, 2), V(:, 1))); - % the last 2 generalized eigenvectors are eigenvectors - assert (isequal ((A - J(3, 3) * eye (4)) * V(:, 3), zeros (4, 1))); - assert (isequal ((A - J(4, 4) * eye (4)) * V(:, 4), zeros (4, 1))); + % rewrite + syms x + y1 = sinint (x); + y2 = rewrite (y1, 'Integral'); + d1 = diff (y1, x); + d2 = diff (y2, x); + v1 = double (subs (d1, x, 2)); + v2 = double (subs (d2, x, 2)); + assert (v1, v2, -eps) +6 tests, 5 passed, 1 known failure, 0 skipped +[inst/@sym/imag.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/imag.m +***** assert (isequal (imag (sym (4) + 3i),3)) ***** test - % scalars - assert (isequal (jordan (sym (-10)), sym (-10))); - assert (isequal (jordan (sym ('x')), sym ('x'))); + syms x y real + z = x + 1i*y; + assert (isequal (imag (z),y)) ***** test - % diagonal matrices - A = diag (sym ([6 6 7])); - [V1, D] = eig (A); - [V2, J] = jordan (A); - assert (isequal (V1, V2)); - assert (isequal (D, J)); + syms x y real + Z = [4 x + 1i*y; 1i*y 4 + 3i]; + assert (isequal (imag (Z),[0 y; y 3])) ***** test - % matrices of unknown entries - A = [sym('a') sym('b'); sym('c') sym('d')]; - [V, D] = eig (A); - J = jordan (A); - assert (isequal (simplify (D), simplify (J))); + syms x real + d = exp (x*i); + assert (isequal (imag (d), sin (x))) ***** test - % matrices of mixed entries - A = [sym('x')+9 sym('y'); sym(0) 6]; - [V, D] = eig (A); - J = jordan (A); - assert (isequal (simplify (D), simplify (J))); + % round trip + syms x + d = 3 - 5i; + f = imag (x); + A = imag (d); + h = function_handle (f); + B = h (d); + assert (A, B) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/uplus.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/uplus.m +[inst/@sym/columns.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/columns.m ***** test - syms x - assert (isa (+x, 'sym')) - assert (isequal (+x, x)) + a = sym([1 2 3]); + assert (columns(a) == 3) ***** test - A = sym([0 -1 inf]); - assert( isequal ( +A, A)) + a = sym([1; 2]); + assert (columns(a) == 1) 2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/intersect.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/intersect.m +[inst/@sym/latex.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/latex.m ***** test - A = sym([1 2 3]); - B = sym([1 2 4]); - C = intersect(A, B); - D = sym([1 2]); - assert (isequal (C, D)) + syms x + y = sin(x); + assert (strcmp (latex (y), '\sin{\left(x \right)}')) +***** assert (strcmp (latex (exp (sym('x'))), 'e^{x}')) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/transpose.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/transpose.m ***** test - % one nonsym - A = sym([1 2 3]); - B = [1 2 4]; - C = intersect(A, B); - D = sym([1 2]); - assert (isequal (C, D)) + x = sym(1); + assert (isequal (x.', x)) +***** assert (isempty (sym([]).')) ***** test - % empty - A = sym([1 2 3]); - C = intersect(A, A); - assert (isequal (C, A)) + syms x; + assert (isequal (x.', x)) ***** test - % empty input - A = sym([1 2]); - C = intersect(A, []); - assert (isempty (C)) + A = [1 2; 3 4]; + assert(isequal( sym(A).' , sym(A.') )) ***** test - % scalar - syms x - assert (isequal (intersect([x 1], x), x)) - assert (isequal (intersect(x, x), x)) + A = [1 2] + 1i; + assert(isequal( sym(A).' , sym(A.') )) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/rref.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/rref.m ***** test - A = interval(sym(1), 3); - B = interval(sym(2), 5); - C = intersect(A, B); - assert( isequal( C, interval(sym(2), 3))) -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@sym/isna.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isna.m + A = sym([1 2; 3 4]); + [r, k] = rref(A); + assert (isequal (r, eye(2))) + assert (isequal (k, [1 2])) +***** assert (isequal (rref(sym([2 1])), [1 sym(1)/2])) +***** assert (isequal (rref(sym([1 2; 2 4])), [1 2; 0 0])) +***** assert (isequal (rref(sym([0 0; 2 4])), [1 2; 0 0])) ***** test - % no sym should be NA - syms x oo - assert (~isna(sym(1))) - assert (~isna(x)) - assert (~isna(oo)) - assert (~isna(sym(nan))) - assert (isequal (isna (sym ([1 nan])), [false false])) -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@sym/sym2poly.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sym2poly.m -***** shared x,y,a,b,c - syms x y a b c -***** assert (isequal (sym2poly (x^2 + 3*x - 4), [1 3 -4])) -***** assert (isequal (sym2poly (x^6 - x^3), [1 0 0 -1 0 0 0])) -***** assert (isequal (sym2poly (x^2 + 3*x - 4, x), [1 3 -4])) -***** assert (norm (sym2poly (pi*x^2 + exp(sym(1))) - [pi 0 exp(1)]) < 10*eps) -***** assert (isa (sym2poly (x^2 + 3*x - 4), 'double')) -***** assert (isa (sym2poly (x^2 + 3*x - 4, x), 'sym')) -***** assert (isequal (sym2poly (x^2+y*x, x), [sym(1) y sym(0)])) -***** assert (isequal (sym2poly (x^2+y*x, y), [x x^2])) -***** assert (isequal (sym2poly (poly2sym ([a b c], x), x), [a b c])) -***** assert (isequal (poly2sym (sym2poly(a*x^2 + c, x), x), a*x^2 + c)) -***** assert (isequal (sym2poly (poly2sym ([1 2 3])), [1 2 3])) -***** error - % too many symbols for single-input - p = a*x^2 + 2; - c = sym2poly (p); -***** assert (isequal (sym2poly (sym(5)), sym(5))) -13 tests, 13 passed, 0 known failure, 0 skipped -[inst/@sym/columns.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/columns.m + A = sym([1 2 3; 2 3 4]); + [r, k] = rref(A); + assert (isequal (r, [1 0 -1; 0 1 2])) + assert (isequal (k, [1 2])); +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/ellipticK.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipticK.m +***** error ellipticK (sym(1), 2) +***** assert (isequal (ellipticK (sym (0)), sym (pi)/2)) +***** assert (isequal (ellipticK (sym (-inf)), sym (0))) +***** assert (double (ellipticK (sym (1)/2)), 1.854074677, 10e-10) +***** assert (double (ellipticK (sym (pi)/4)), 2.225253684, 10e-10) +***** assert (double (ellipticK (sym (-55)/10)), 0.9324665884, 10e-11) ***** test - a = sym([1 2 3]); - assert (columns(a) == 3) + % compare to double ellipke + m = 1/5; + ms = sym(1)/5; + [K, E] = ellipke (m); + assert (double (ellipticK (ms)), K, -1e-15) + assert (double (ellipticE (ms)), E, -1e-15) ***** test - a = sym([1; 2]); - assert (columns(a) == 1) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/le.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/le.m + % compare to double ellipke + if (exist ('OCTAVE_VERSION', 'builtin')) + m = -10.3; + ms = -sym(103)/10; + [K, E] = ellipke (m); + assert (double (ellipticK (ms)), K, -1e-15) + assert (double (ellipticE (ms)), E, -1e-15) + end +***** test + % compare to Maple + us = vpa (ellipticK (sym (7)), 40); + % > evalf(EllipticK(sqrt(7)), 40); + maple = vpa ('0.6168027921799632674669917683443602673441', 40) - ... + vpa ('0.9114898734184488922164103102629560336918j', 40); + assert (abs (double (maple - us)), 0, 1e-39) +9 tests, 9 passed, 0 known failure, 0 skipped +[inst/@sym/ne.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ne.m ***** test % simple - x = sym(1); y = sym(1); e = x <= y; - assert (logical (e)) - x = sym(1); y = sym(2); e = x <= y; - assert (logical (e)) + x = sym(1); y = sym(1); e = x ~= y; + assert (~logical (e)) + x = sym(1); y = sym(2); e = x ~= y; + assert (logical(e)) ***** test % array -- array syms x a = sym([1 3 3 2*x]); b = sym([2 x 3 10]); - e = a <= b; + e = a ~= b; assert (isa (e, 'sym')) assert (logical (e(1))) assert (isa (e(2), 'sym')) - assert (isequal (e(2), 3 <= x)) - assert (logical (e(3))) + assert (isequal (e(2), 3 ~= x)) + assert (~logical (e(3))) assert (isa (e(4), 'sym')) - assert (isequal (e(4), 2*x <= 10)) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/equationsToMatrix.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/equationsToMatrix.m + assert (isequal (e(4), 2*x ~= 10)) ***** test - syms x y z - [A, B] = equationsToMatrix ([x + y - z == 1, 3*x - 2*y + z == 3, 4*x - 2*y + z + 9 == 0], [x, y, z]); - a = sym ([1 1 -1; 3 -2 1; 4 -2 1]); - b = sym ([1; 3; -9]); - assert (isequal (A, a)) - assert (isequal (B, b)) + % oo + syms oo x + e = oo ~= x; + assert (isa (e, 'sym')) + s = strtrim (disp (e, 'flat')); + % SymPy <= 0.7.6.x will be '!=', newer gives 'Ne', test both + assert (strcmp (s, 'oo != x') || strcmp (s, 'Ne(oo, x)')) ***** test - syms x y z - A = equationsToMatrix ([3*x + -3*y - 5*z == 9, 4*x - 7*y + -3*z == -1, 4*x - 9*y - 3*z + 2 == 0], [x, y, z]); - a = sym ([3 -3 -5; 4 -7 -3; 4 -9 -3]); - assert (isequal (A, a)) + % nan + syms oo x + snan = sym(nan); + e = snan ~= sym(0); + assert (logical (e)) + e = snan ~= snan; + assert (logical (e)) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/interval.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/interval.m ***** test - syms x y - [A, B] = equationsToMatrix ([3*x + 9*y - 5 == 0, -8*x - 3*y == -2]); - a = sym ([3 9; -8 -3]); - b = sym ([5; -2]); - assert (isequal (A, a)) - assert (isequal (B, b)) + a = interval(sym(1), 2); + assert (isa (a, 'sym')) ***** test - % override symvar order - syms x y - [A, B] = equationsToMatrix ([3*x + 9*y - 5 == 0, -8*x - 3*y == -2], [y x]); - a = sym ([9 3; -3 -8]); - b = sym ([5; -2]); - assert (isequal (A, a)) - assert (isequal (B, b)) + % some set subtraction + a = interval(sym(0), 4); + b = interval(sym(0), 1); + c = interval(sym(1), 4, true); + q = a - b; + assert (isequal( q, c)) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/ones.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ones.m ***** test - syms x y z - [A, B] = equationsToMatrix ([x - 9*y + z == -5, -9*y*z == -5], [y, x]); - a = sym ([[-9 1]; -9*z 0]); - b = sym ([-5 - z; -5]); - assert (isequal (A, a)) - assert (isequal (B, b)) + y = ones(sym(2)); + x = [1 1; 1 1]; + assert( isequal( y, sym(x))) ***** test - syms x y - [A, B] = equationsToMatrix (-6*x + 4*y == 5, 4*x - 4*y - 5, x, y); - a = sym ([-6 4; 4 -4]); - b = sym ([5; 5]); - assert (isequal (A, a)) - assert (isequal (B, b)) + y = ones(sym(2), 1); + x = [1; 1]; + assert( isequal( y, sym(x))) ***** test - % vertical list of equations - syms x y - [A, B] = equationsToMatrix ([-6*x + 4*y == 5; 4*x - 4*y - 5], [x y]); - a = sym ([-6 4; 4 -4]); - b = sym ([5; 5]); - assert (isequal (A, a)) - assert (isequal (B, b)) + y = ones(sym(1), 2); + x = [1 1]; + assert( isequal( y, sym(x))) ***** test - syms x y - [A, B] = equationsToMatrix (5*x == 1, y, x - 6*y - 7, y); - a = sym ([0; 1; -6]); - b = sym ([1 - 5*x; 0; -x + 7]); - assert (isequal (A, a)) - assert (isequal (B, b)) -***** error - syms x y - [A, B] = equationsToMatrix (x^2 + y^2 == 1, x - y + 1, x, y); + y = ones (sym([2 3])); + x = sym (ones ([2 3])); + assert (isequal (y, x)) +***** assert( isa( ones(sym(2), 'double'), 'double')) +***** assert( isa( ones(3, sym(3), 'single') , 'single')) +***** assert( isa( ones(3, sym(3)), 'sym')) +***** assert( isa( ones(3, sym(3), 'sym'), 'sym')) +***** xtest + % Issue #13 + assert( isa( ones(3, 3, 'sym'), 'sym')) +!!!!! known failure +invalid data type specified +9 tests, 8 passed, 1 known failure, 0 skipped +[inst/@sym/fliplr.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/fliplr.m ***** test - % single equation + % simple syms x - [A, B] = equationsToMatrix (3*x == 2, x); - a = sym (3); - b = sym (2); - assert (isequal (A, a)) - assert (isequal (B, b)) + A = [x 2; sym(pi) x]; + B = [2 x; x sym(pi)]; + assert (isequal (fliplr(A), B)) ***** test - % single equation w/ symvar - syms x - [A, B] = equationsToMatrix (3*x == 2); - a = sym (3); - b = sym (2); - assert (isequal (A, a)) - assert (isequal (B, b)) -***** error + % simple, odd # cols syms x - equationsToMatrix (3*x == 2, [x x]) -12 tests, 12 passed, 0 known failure, 0 skipped -[inst/@sym/kroneckerDelta.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/kroneckerDelta.m -***** error kroneckerDelta (sym(1), 2, 3) + A = [x 2 sym(pi); x 1 2]; + B = [sym(pi) 2 x; 2 1 x]; + assert (isequal (fliplr(A), B)) ***** test + % scalar syms x - assert (isequal (kroneckerDelta (x, x), sym(1))) -***** assert (isequal (kroneckerDelta ([sym(1) 2 3], [1 2 0]), sym([1 1 0]))) + assert (isequal (fliplr(x), x)) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/asin.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/asin.m +***** error asin (sym(1), 2) +***** assert (isequaln (asin (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); +***** test + f1 = asin(x); + f2 = asin(d); + assert( abs(double(f1) - f2) < 1e-15 ) +***** test + D = [d d; d d]; + A = [x x; x x]; + f1 = asin(A); + f2 = asin(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip - syms x y - f = kroneckerDelta (x, y); + y = sym('y'); + A = asin (d); + f = asin (y); h = function_handle (f); - assert (h (1, 2), 0) - assert (h (2, 2), 1) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/rdivide.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/rdivide.m + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/isscalar.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isscalar.m +***** assert(isscalar(sym('x'))) ***** test - % scalar - syms x - assert (isa (x ./ 1, 'sym')) - assert (isa (x ./ x, 'sym')) - assert (isequal (x ./ 1, x)) - assert (isequal (x ./ x, sym(1))) + a = sym([1 2 3]); + assert(~isscalar(a)) +***** assert(~isscalar(sym([]))) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/nextprime.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/nextprime.m +***** assert (isequal (nextprime(sym(2)), 3)); +***** assert (isequal (nextprime(sym(18)), 19)); +***** assert (isequal (nextprime(sym([1 2 3])), [2 3 5])); +***** assert (isequal (nextprime(sym([-1 0])), [2 2])); ***** test - % matrix-scalar - D = 2*[0 1; 2 3]; - A = sym(D); - assert (isequal ( A./2 , D/2 )) - assert (isequal ( A./sym(2) , D/2 )) - assert (isequal ( D./sym(2) , D/2 )) + % result is a sym + p = nextprime(sym(2)); + assert (isa (p, 'sym')) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/asinh.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/asinh.m +***** error asinh (sym(1), 2) +***** assert (isequaln (asinh (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); ***** test - % matrix ./ matrix - D = [1 2; 3 4]; - A = sym(D); - assert (isequal ( A./A , D./D )) - assert (isequal ( A./D , D./D )) - assert (isequal ( D./A , D./D )) + f1 = asinh(x); + f2 = asinh(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - % matrix ./ matrix with symbols - syms x y - A = [x y; x^2 2*y]; - B = [y x; x y]; - assert (isequal ( A./A , sym(ones(2,2)) )) - assert (isequal ( A./B , [x/y y/x; x 2] )) + D = [d d; d d]; + A = [x x; x x]; + f1 = asinh(A); + f2 = asinh(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test - % scalar ./ matrix - D = [1 2; 3 4]; - A = sym(D); - assert (isequal ( 12./A , 12./D )) + % round trip + y = sym('y'); + A = asinh (d); + f = asinh (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/ldivide.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ldivide.m +[inst/@sym/besseljn.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/besseljn.m ***** test - % scalar + % roundtrip syms x - assert (isa (x .\ 1, 'sym')) - assert (isa (x .\ x, 'sym')) - assert (isequal (x .\ 1, 1/x)) - assert (isequal (x .\ x, sym(1))) + A = double(besseljn(sym(2), sym(9))); + q = besseljn(sym(2), x); + h = function_handle(q); + B = h(9); + assert (abs (A - B) <= eps) +***** error jn(sym('x')) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/cosint.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cosint.m +***** error cosint (sym(1), 2) +***** xtest + assert (isequaln (cosint (sym(nan)), sym(nan))) +!!!!! known failure +assert (isequaln (cosint (sym (nan)), sym (nan))) failed +***** shared x, d + d = 1; + x = sym('1'); ***** test - % matrix-scalar - D = [1 1; 2 3]; - A = sym(D); - assert (isequal ( A .\ 6 , D .\ 6 )) - assert (isequal ( A .\ sym(6) , D .\ 6 )) - assert (isequal ( D .\ sym(6) , D .\ 6 )) + f1 = cosint(x); + f2 = 0.3374039229009681346626; + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - % matrix-matrix - D = [1 2; 3 4]; - A = sym(D); - assert (isequal ( A .\ A , D .\ D )) - assert (isequal ( A .\ D , D .\ D )) - assert (isequal ( D .\ A , D .\ D )) + D = [d d; d d]; + A = [x x; x x]; + f1 = cosint(A); + f2 = 0.3374039229009681346626; + f2 = [f2 f2; f2 f2]; + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test - % matrix .\ matrix with symbols - syms x y - A = [x y; x^2 2*y]; - B = [y x; x y]; - assert (isequal ( A .\ A , sym(ones(2, 2)) )) - assert (isequal ( B .\ A , [x/y y/x; x 2] )) + % round trip + y = sym('y'); + A = cosint (d); + f = cosint (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) ***** test - % scalar .\ matrix - D = 3*[1 2; 3 4]; - A = sym(D); - assert (isequal ( 3 .\ A , 3 .\ D )) + % rewrite + syms x + y1 = cosint (x); + y2 = rewrite (y1, 'Integral'); + d1 = diff (y1, x); + d2 = diff (y2, x); + assert (isequal (d1, simplify(d2))) + v1 = double (subs (d1, x, 2)); + v2 = double (subs (d2, x, 2)); + assert (v1, v2, -eps) +6 tests, 5 passed, 1 known failure, 0 skipped +[inst/@sym/plus.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/plus.m +***** test + % basic addition + syms x + assert (isa (x+5, 'sym')) + assert (isa (5+x, 'sym')) + assert (isa (5+sym(4), 'sym')) + assert (isequal (5+sym(4), sym(9))) +***** test + % array addition + syms x + D = [0 1; 2 3]; + A = [sym(0) 1; sym(2) 3]; + DZ = D - D; + assert( isequal ( A + D , 2*D )) + assert( isequal ( D + A , 2*D )) + assert( isequal ( A + A , 2*D )) + assert( isequal ( A + 2 , D + 2 )) + assert( isequal ( 4 + A , 4 + D )) +***** test + % ensure MatrixExpr can be manipulated somewhat + syms n m integer + A = sym('A', [n m]); + B = subs(A, [n m], [5 6]); + B = B + 1; + assert (isa (B, 'sym')) + C = B(1, 1); % currently makes a MatrixElement + C = C + 1; + assert (isa (C, 'sym')) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/tanh.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/tanh.m +***** error tanh (sym(1), 2) +***** assert (isequaln (tanh (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); +***** test + f1 = tanh(x); + f2 = tanh(d); + assert( abs(double(f1) - f2) < 1e-15 ) +***** test + D = [d d; d d]; + A = [x x; x x]; + f1 = tanh(A); + f2 = tanh(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) +***** test + % round trip + y = sym('y'); + A = tanh (d); + f = tanh (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/acot.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/acot.m -***** error acot (sym(1), 2) -***** assert (isequaln (acot (sym(nan)), sym(nan))) +[inst/@sym/tan.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/tan.m +***** error tan (sym(1), 2) +***** assert (isequaln (tan (sym(nan)), sym(nan))) ***** shared x, d d = 1; x = sym('1'); ***** test - f1 = acot(x); - f2 = acot(d); + f1 = tan(x); + f2 = tan(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = acot(A); - f2 = acot(D); + f1 = tan(A); + f2 = tan(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = acot (d); - f = acot (y); + A = tan (d); + f = tan (y); h = function_handle (f); B = h (d); assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/erfcinv.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/erfcinv.m -***** error erfcinv (sym(1), 2) -***** assert (isequaln (erfcinv (sym(nan)), sym(nan))) +[inst/@sym/times.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/times.m +***** test + % scalar + syms x + assert (isa (x.*2, 'sym')) + assert (isequal (x.*2, x*2)) + assert (isequal (2.*sym(3), sym(6))) + assert (isequal (sym(2).*3, sym(6))) +***** test + % matrix-matrix and matrix-scalar + D = [0 1; 2 3]; + A = sym(D); + assert (isequal ( 2.*A , 2*D )) + assert (isequal ( A.*2 , 2*D )) + assert (isequal ( A.*A , D.*D )) + assert (isequal ( A.*D , D.*D )) + assert (isequal ( D.*A , D.*D )) +***** test + syms x + A = [1 x]; + B = [2 3]; + assert (isequal (A.*B, [2 3*x])) +***** test + % immutable test + A = sym([1 2]); + B = sym('ImmutableDenseMatrix([[Integer(1), Integer(2)]])'); + assert (isequal (A.*A, B.*B)) +***** test + % MatrixSymbol test + A = sym([1 2; 3 4]); + B = sym('ImmutableDenseMatrix([[Integer(1), Integer(2)], [Integer(3), Integer(4)]])'); + C = sym('MatrixSymbol("C", 2, 2)'); + assert (~ isempty (strfind (sympy (C.*C), 'Hadamard'))) + assert (~ isempty (strfind (sympy (A.*C), 'Hadamard'))) + assert (~ isempty (strfind (sympy (C.*A), 'Hadamard'))) + assert (~ isempty (strfind (sympy (B.*C), 'Hadamard'))) + assert (~ isempty (strfind (sympy (C.*B), 'Hadamard'))) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/partfrac.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/partfrac.m +***** test + % basic + syms x y z + assert(logical( partfrac(y/(x + 2)/(x + 1),x) == -y/(x + 2) + y/(x + 1) )) + assert(logical( factor(partfrac(x^2/(x^2 - y^2),y)) == factor(x/(2*(x + y)) + x/(2*(x - y)) ))) + assert(logical( factor(partfrac(x^2/(x^2 - y^2),x)) == factor(-y/(2*(x + y)) + y/(2*(x - y)) + 1 ))) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@sym/resize.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/resize.m +***** test + B = sym([1 0 0; 0 0 0]); + assert (isequal (resize (sym(1), 2, 3), B)) + assert (isequal (resize (sym(1), [2 3]), B)) +***** test + B = sym([1 0; 0 0]); + assert (isequal (resize (sym(1), 2), B)) +***** test + A = sym([pi 2; 3 4]); + assert (isequal (resize (A, 1), sym(pi))) +***** assert (isequal (size (resize (sym(1), 0, 0)), [0 0])) +***** assert (isequal (size (resize (sym(1), 6, 0)), [6 0])) +***** assert (isequal (size (resize (sym(1), 0, 3)), [0 3])) +***** error resize (sym(1)) +***** error resize (sym(1), 2, 3, 4) +***** error resize (sym(1), [2 3 4]) +9 tests, 9 passed, 0 known failure, 0 skipped +[inst/@sym/chol.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/chol.m +***** error chol (sym ([1 2; 3 4])); +***** error chol (sym ([1 2; 3 4; 5 6])); +***** test + A = chol(hilb(sym(2))); + B = [[1 0]; sym(1)/2 sqrt(sym(3))/6]; + assert( isequal( A, B )) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/sinhint.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sinhint.m +***** error sinhint (sym(1), 2) +***** xtest + assert (isequaln (sinhint (sym(nan)), sym(nan))) +!!!!! known failure +assert (isequaln (sinhint (sym (nan)), sym (nan))) failed ***** shared x, d d = 1; x = sym('1'); ***** test - f1 = erfcinv(x); - f2 = erfcinv(d); + f1 = sinhint(x); + f2 = 1.057250875375728514572; assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = erfcinv(A); - f2 = erfcinv(D); + f1 = sinhint(A); + f2 = 1.057250875375728514572; + f2 = [f2 f2; f2 f2]; assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test - % round trip - y = sym('y'); - A = erfcinv (d); - f = erfcinv (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) + % round trip + y = sym('y'); + A = sinhint (d); + f = sinhint (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 4 passed, 1 known failure, 0 skipped +[inst/@sym/zeros.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/zeros.m +***** test + y = zeros(sym(2)); + x = [0 0; 0 0]; + assert( isequal( y, sym(x))) +***** test + y = zeros(sym(2), 1); + x = [0; 0]; + assert( isequal( y, sym(x))) +***** test + y = zeros(sym(1), 2); + x = [0 0]; + assert( isequal( y, sym(x))) +***** test + y = zeros (sym([2 3])); + x = sym (zeros ([2 3])); + assert (isequal (y, x)) +***** assert( isa( zeros(sym(2), 'double'), 'double')) +***** assert( isa( zeros(3, sym(3), 'single') , 'single')) +***** assert( isa( zeros(3, sym(3)), 'sym')) +***** assert( isa( zeros(3, sym(3), 'sym'), 'sym')) +***** xtest + % Issue #13 + assert( isa( zeros(3, 3, 'sym'), 'sym')) +!!!!! known failure +invalid data type specified +9 tests, 8 passed, 1 known failure, 0 skipped +[inst/@sym/limit.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/limit.m +***** error limit (sym(1), 2, 3, 4, 5) +***** shared x, oo + syms x + oo = sym(inf); +***** assert (isa (limit(x, x, pi), 'sym')) +***** assert (isequal (limit(x, x, pi), sym(pi))) +***** assert (isequal (limit(sin(x)/x, x, 0), 1)) +***** test + % left/right-hand limit + assert (isequal (limit(1/x, x, 0, 'right'), oo)) + assert (isequal (limit(1/x, x, 0), oo)) + assert (isequal (limit(1/x, x, 0, 'left'), -oo)) + assert (isequal (limit(1/x, x, oo), 0)) + assert (isequal (limit(sign(x), x, 0, 'left'), -1)) + assert (isequal (limit(sign(x), x, 0, 'right'), 1)) + assert (isequal (limit(sign(x), x, 0, '-'), -1)) + assert (isequal (limit(sign(x), x, 0, '+'), 1)) +***** test + % matrix + syms y + A = [x 1/x x*y]; + B = sym([3 sym(1)/3 3*y]); + assert (isequal (limit(A, x, 3), B)) +***** test + % omitting arguments + syms a + assert (isequal (limit(a), 0)) + assert (isequal (limit(a*x+a+2), a+2)) + assert (isequal (limit(a*x+a+2, 6), 7*a+2)) +***** test + % constants + assert (isequal (limit(sym(6)), 6)) + assert (isequal (limit(sym(6), 7), 6)) + assert (isequal (limit([sym(6) sym(2)], 7), [6 2])) +***** test + % double constant, with sym limit + a = limit (6, sym(0)); + assert (isa (a, 'sym')) + assert (isequal (a, sym(6))) +9 tests, 9 passed, 0 known failure, 0 skipped +[inst/@sym/inv.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/inv.m +***** test + % scalar + syms x + assert (isequal (inv(x), 1/x)) +***** test + % diagonal + syms x + A = [sym(1) 0; 0 x]; + B = [sym(1) 0; 0 1/x]; + assert (isequal (inv(A), B)) +***** test + % 2x2 inverse + A = [1 2; 3 4]; + assert (max (max (abs (double (inv (sym (A))) - inv(A)))) <= 3*eps) +***** error + syms a; + A = [a a; a a]; + inv(A) +***** error + syms a; + A = [a a]; + inv(A) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/piecewise.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/piecewise.m +***** test + % basic + syms x real + f = piecewise (abs (x) < 1, 1); + assert (isnan (subs (f, -1))); + assert (isequal (subs (f, 0), 1)); + assert (isnan (subs (f, 1))); +***** test + % heaviside + syms x real + f = rewrite (heaviside (x, 1 / sym (2)), 'Piecewise'); + g = piecewise (x < 0, 0, x == 0, 1 / sym (2), x > 0, 1); + assert (logical (simplify (f == g))); +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/ellipticCE.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipticCE.m +***** error ellipticCE (sym (1), 2) +***** assert (isequal (ellipticCE (sym (0)), sym (1))) +***** assert (isequal (ellipticCE (sym (1)), sym (pi)/2)) +***** assert (double (ellipticCE (sym (pi)/4)), 1.482786927, 10e-10) +***** assert (double (ellipticCE (sym (pi)/2)), 1.775344699, 10e-10) 5 tests, 5 passed, 0 known failure, 0 skipped [inst/@sym/sym.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sym.m @@ -6922,62 +9952,6 @@ error ('use another variable') end 86 tests, 86 passed, 0 known failure, 0 skipped -[inst/@sym/ne.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ne.m -***** test - % simple - x = sym(1); y = sym(1); e = x ~= y; - assert (~logical (e)) - x = sym(1); y = sym(2); e = x ~= y; - assert (logical(e)) -***** test - % array -- array - syms x - a = sym([1 3 3 2*x]); - b = sym([2 x 3 10]); - e = a ~= b; - assert (isa (e, 'sym')) - assert (logical (e(1))) - assert (isa (e(2), 'sym')) - assert (isequal (e(2), 3 ~= x)) - assert (~logical (e(3))) - assert (isa (e(4), 'sym')) - assert (isequal (e(4), 2*x ~= 10)) -***** test - % oo - syms oo x - e = oo ~= x; - assert (isa (e, 'sym')) - s = strtrim (disp (e, 'flat')); - % SymPy <= 0.7.6.x will be '!=', newer gives 'Ne', test both - assert (strcmp (s, 'oo != x') || strcmp (s, 'Ne(oo, x)')) -***** test - % nan - syms oo x - snan = sym(nan); - e = snan ~= sym(0); - assert (logical (e)) - e = snan ~= snan; - assert (logical (e)) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/rank.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/rank.m -***** test - A = sym([1 2; 3 4]); - assert (rank(A) == 2); -***** test - A = sym([1 2 3; 3 4 5]); - assert (rank(A) == 2); -***** test - A = sym([1 2; 1 2]); - assert (rank(A) == 1); -***** test - A = sym([1 2; 3 4]); - assert (rank(A) == 2); -***** assert (rank(sym(1)) == 1); -***** assert (rank(sym(0)) == 0); -***** assert (rank(sym('x', 'positive')) == 1); -7 tests, 7 passed, 0 known failure, 0 skipped [inst/@sym/not.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/not.m ***** shared t, f @@ -7018,1010 +9992,95 @@ assert (strcmp (strtrim (s), '~x') || strcmpi (strtrim (s), 'Not(x)')) ***** error not (sym(1), 2) 8 tests, 8 passed, 0 known failure, 0 skipped -[inst/@sym/subsindex.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/subsindex.m -***** test - i = sym(1); - a = 7; - assert(a(i)==a); - i = sym(2); - a = 2:2:10; - assert(a(i)==4); -***** test - i = sym([1 3 5]); - a = 1:10; - assert( isequal (a(i), [1 3 5])) -***** test - i = sym([1 3 5]); - a = sym(1:10); - assert( isequal (a(i), sym([1 3 5]))); -***** test - % should be an error if it doesn't convert to double - syms x - a = 1:10; - try - a(x) - waserr = false; - catch - waserr = true; - end - assert(waserr) -***** test - syms x - assert (isequal (x(sym (true)), x)) - assert (isequal (x(sym (false)), sym ([]))) -***** test - x = 6; - assert (isequal (x(sym (true)), 6)) - assert (isequal (x(sym (false)), [])) -***** test - a = sym([10 12 14]); - assert (isequal (a(sym ([true false true])), a([1 3]))) - assert (isequal (a(sym ([false false false])), sym (ones(1,0)))) -***** test - a = [10 11; 12 13]; - p = [true false; true true]; - assert (isequal (a(sym (p)), a(p))) - p = [false false false]; - assert (isequal (a(sym (p)), a(p))) -***** error - a = [10 12]; - I = [sym(true) 2]; - b = a(I); -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/kron.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/kron.m -***** error kron (sym (2)) -***** test - syms x y - A = [sin(x), sin(y); x, y]; - B = ones(2); - expected = sym([sin(x), sin(x), sin(y), sin(y); sin(x), sin(x), sin(y), sin(y); x, x, y, y; x, x, y, y]); - assert (isequal (kron(A, B), expected)) -***** test - syms x y - A = [sin(x), sin(y); x, y]; - B = 2; - assert (isequal (kron(A, B), 2*A)) -***** test - syms x y - A = [sin(x), sin(y)]; - B = 2; - assert (isequal( kron(B, A), 2*A)) -***** test - syms x y; - X = [tan(x), tan(x)]; - Y = [cot(x); cot(x)]; - expected = sym(ones(2)); - assert (isequal (simplify(kron(X, Y)), expected)) -***** test - syms x y z - X = [x, y, z]; - Y = [y, y; x, x]; - expected = [x*y, x*y, y^2, y^2, y*z, y*z; x^2, x^2, x*y, x*y, x*z, x*z]; - assert (isequal (kron(X, Y), expected)) -***** test - syms x y - X = [x, x^2; y, y^2]; - Y = [1, 0; 0, 1]; - expected = [x, x^2, 0, 0; y, y^2, 0, 0; 0, 0, x, x^2; 0, 0, y, y^2]; - assert (isequal (kron(Y, X), expected)) -***** test - syms x y z - assert (isequal (kron (x, y, z), x*y*z)) - assert (isequal (kron (x, y, z, 4), 4*x*y*z)) - assert (isequal (kron ([2 3], y, z), [2 3]*y*z)) - assert (isequal (kron ([2 3], [4; 5], y), [8 12; 10 15]*y)) -***** test - syms x y - A = kron ([x y], [1, -1; -1, 1], [2 3; 4 5]); - D = kron ([7 9], [1, -1; -1, 1], [2 3; 4 5]); - A = double (subs (A, [x y], [7 9])); - assert (isequal (A, D)) -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/sinhint.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sinhint.m -***** error sinhint (sym(1), 2) -***** xtest - assert (isequaln (sinhint (sym(nan)), sym(nan))) -!!!!! known failure -assert (isequaln (sinhint (sym (nan)), sym (nan))) failed +[inst/@sym/cosh.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cosh.m +***** error cosh (sym(1), 2) +***** assert (isequaln (cosh (sym(nan)), sym(nan))) ***** shared x, d d = 1; x = sym('1'); ***** test - f1 = sinhint(x); - f2 = 1.057250875375728514572; + f1 = cosh(x); + f2 = cosh(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = sinhint(A); - f2 = 1.057250875375728514572; - f2 = [f2 f2; f2 f2]; + f1 = cosh(A); + f2 = cosh(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = sinhint (d); - f = sinhint (y); + A = cosh (d); + f = cosh (y); h = function_handle (f); B = h (d); assert (A, B, -eps) -5 tests, 4 passed, 1 known failure, 0 skipped -[inst/@sym/solve.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/solve.m -***** test - % Simple, single variable, single solution - syms x - d = solve(10*x == 50); - assert (isequal (d, 5)) -***** test - % Single variable, multiple solutions - syms x - d = solve(x^2 == 4); - assert (length(d) == 2); - assert (isequal (d, [2; -2]) || isequal (d, [-2; 2])) -***** shared x,y,eq - syms x y - eq = 10*x == 20*y; -***** test - d = solve(eq, x); - assert (isequal (d, 2*y)) -***** test - d = solve(eq, y); - assert (isequal (d, x/2)) -***** test - d = solve(eq); - assert (isequal (d, 2*y)) -***** shared x,y - syms x y -***** test - d = solve(2*x - 3*y == 0, x + y == 1); - assert (isequal (d.x, sym(3)/5) && isequal(d.y, sym(2)/5)) -***** test - d = solve(2*x - 3*y == 0, x + y == 1, x, y); - assert (isequal (d.x, sym(3)/5) && isequal(d.y, sym(2)/5)) -***** test - % Multiple solutions, multiple variables - d = solve(x^2 == 4, x + y == 1); - assert (length(d) == 2); - % FIXME: SMT has d.x gives vector and d.y giving vector, what is - % more intuitive? - for i = 1:2 - assert (isequal (d{i}.x + d{i}.y, 1)) - assert (isequal ((d{i}.x)^2, 4)) - end -***** test - % No solutions - syms x y z - d = solve(x == y, z); - assert (isempty (d)); -***** test - % Multiple outputs with single solution - [X, Y] = solve(2*x + y == 5, x + y == 3); - assert (isequal (X, 2)) - assert (isequal (Y, 1)) -***** test - % system: vector of equations, vector of vars - [X, Y] = solve([2*x + y == 5, x + y == 3], [x y]); - assert (isequal (X, 2)) - assert (isequal (Y, 1)) -***** test - % system: vector of equations, individual vars - [X, Y] = solve([2*x + y == 5, x + y == 3], x, y); - assert (isequal (X, 2)) - assert (isequal (Y, 1)) -***** test - % system: individual equations, vector of vars - [X, Y] = solve(2*x + y == 5, x + y == 3, [x y]); - assert (isequal (X, 2)) - assert (isequal (Y, 1)) -***** test - % Multiple outputs with multiple solns - [X, Y] = solve(x*x == 4, x == 2*y); - assert ((isequal (X, [2; -2]) && isequal (Y, [1; -1])) || ... - (isequal (X, [-2; 2]) && isequal (Y, [-1; 1]))) -***** test - % Multiple outputs with multiple solns, specify vars - [X, Y] = solve(x*x == 4, x == 2*y, x, y); - assert ((isequal (X, [2; -2]) && isequal (Y, [1; -1])) || ... - (isequal (X, [-2; 2]) && isequal (Y, [-1; 1]))) -***** error - % mult outputs not allowed for scalar equation, even with mult soln (?) - [s1, s2] = solve(x^2 == 4, x); -***** test - % overdetermined - X = solve(2*x - 10 == 0, 3*x - 15 == 0, x); - assert (isequal (X, sym(5))) -***** test - a = solve(2*x >= 10, 10*x <= 50); - assert (isequal( a, x==sym(5))) -***** test - A = solve([2*x == 4*y, 2 == 3], x); - assert (isempty (A)) -***** test - % Issue #850 - A = solve (sym(pi)^2*x + y == 0); - assert (isequal (A, -y/sym(pi)^2)) -***** test - % https://github.com/sympy/sympy/issues/14632 - A = solve([2*x == 4*y, sym(2) == 2], x); - assert (isequal (A, 2*y)) -***** test - % https://github.com/sympy/sympy/issues/14632 - A = solve([2*x^2 == 32*y^2, sym(2) == 2], x); - B = solve([2*x^2 == 32*y^2], x); - assert (isequal (A, B) || isequal (A, flip (B))) -***** test - A = solve ([x+1 0], x); - assert (isequal (A, sym (-1))) -***** test - A = solve (x + 1, x); - assert (isequal (A, sym (-1))) - A = solve (x, x); - assert (isequal (A, sym (0))) -24 tests, 24 passed, 0 known failure, 0 skipped -[inst/@sym/degree.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/degree.m -***** error degree (sym(1), 2, 3) -***** test - syms x - assert (isequal (degree(x^3), 3)) - assert (isequal (degree(x^3 + 6), 3)) -***** test - % specify variable - syms x y - p = x^2 + y*x + 1; - assert (isequal (degree(p), 2)) - assert (isequal (degree(p, x), 2)) - assert (isequal (degree(p, y), 1)) -***** test - syms x a oo - assert (isequal (degree(x^3, a), 0)) - assert (isequal (degree(sym(1), a), 0)) - assert (isequal (degree(sym(0), a), -oo)) -***** xtest - % constant inputs - syms oo - assert (isequal (degree(sym(1)), 0)) - assert (isequal (degree(sym(0)), -oo)) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/trace.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/trace.m -***** test - % scalar - syms x - assert (isequal (trace(x), x)) -***** test - syms x - A = [x 3; 2*x 5]; - assert (isequal (trace(A), x + 5)) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/beta.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/beta.m -***** error beta (sym(1), 2, 3) -***** assert (isequal (double (beta (sym(1), 2)), 1/2)) -***** assert (isinf (double (beta (sym(1), 0)))) +[inst/@sym/ifourier.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ifourier.m +***** error ifourier (sym(1), 2, 3, 4) ***** test - % round trip - syms x y - f = beta (x, y); - h = function_handle (f); - A = h (1.1, 2.2); - B = beta (1.1, 2.2); - assert (A, B) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/vertcat.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/vertcat.m + % matlab SMT compat + syms t r u x w + Pi=sym('pi'); + assert(logical( ifourier(exp(-abs(w))) == 1/(Pi*(x^2 + 1)) )) + assert(logical( ifourier(exp(-abs(x))) == 1/(Pi*(t^2 + 1)) )) + assert(logical( ifourier(exp(-abs(r)),u) == 1/(Pi*(u^2 + 1)) )) + assert(logical( ifourier(exp(-abs(r)),r,u) == 1/(Pi*(u^2 + 1)) )) ***** test % basic - syms x - A = [x; x]; - B = vertcat(x, x); - C = vertcat(x, x, x); - assert (isa (A, 'sym')) - assert (isa (B, 'sym')) - assert (isa (C, 'sym')) - assert (isequal (size(A), [2 1])) - assert (isequal (size(B), [2 1])) - assert (isequal (size(C), [3 1])) -***** test - % basic, part 2 - syms x - A = [x; 1]; - B = [1; x]; - C = [1; 2; x]; - assert (isa (A, 'sym')) - assert (isa (B, 'sym')) - assert (isa (C, 'sym')) - assert (isequal (size(A), [2 1])) - assert (isequal (size(B), [2 1])) - assert (isequal (size(C), [3 1])) -***** test - % column vectors - a = [sym(1); 2]; - b = [sym(3); 4]; - assert (isequal ( [a;b] , [1; 2; 3; 4] )) - assert (isequal ( [a;b;a] , [1; 2; 3; 4; 1; 2] )) -***** test - % row vectors - a = [sym(1) 2]; - b = [sym(3) 4]; - assert (isequal ( [a;b] , [1 2; 3 4] )) - assert (isequal ( [a;b;a] , [1 2; 3 4; 1 2] )) -***** test - % row vector, other row - a = [sym(1) 2]; - assert (isequal ( [a; [sym(3) 4]] , [1 2; 3 4] )) -***** test - % empty vectors - v = [sym(1) sym(2)]; - a = [v; []]; - assert (isequal (a, v)) - a = [[]; v; []]; - assert (isequal (a, v)) - a = [v; []; []]; - assert (isequal (a, v)) -***** xtest - % FIXME: is this Octave bug? worth worrying about - syms x - a = [x; [] []]; - assert (isequal (a, x)) -!!!!! known failure -octave_base_value::map_value(): wrong type argument 'null_matrix' -***** test - % more empty vectors - v = [sym(1) sym(2)]; - q = sym(ones(0, 2)); - assert (isequal ([v; q], v)) -***** error - v = [sym(1) sym(2)]; - q = sym(ones(0, 3)); - w = vertcat(v, q); -***** test - % Octave 3.6 bug: should pass on 3.8.1 and matlab - a = [sym(1) 2]; - assert (isequal ( [a; [3 4]] , [1 2; 3 4] )) - assert (isequal ( [a; sym(3) 4] , [1 2; 3 4] )) - % more examples - syms x - [x [x x]; x x x]; - [[x x] x; x x x]; - [[x x] x; [x x] x]; - [x x x; [x x] x]; -***** test - % issue #700 - A = sym ([1 2]); - B = simplify (A); - assert (isequal ([B; A], [A; B])) -11 tests, 10 passed, 1 known failure, 0 skipped -[inst/@sym/length.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/length.m -***** test - a = sym([1 2 3]); - assert(length(a) == 3); -***** test - % 2D array - a = sym([1 2 3; 4 5 6]); - assert(length(a) == 3); -***** test - % empty - a = sym([]); - assert(length(a) == 0); -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/matlabFunction.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/matlabFunction.m -***** test - % autodetect inputs - syms x y - s = warning('off', 'OctSymPy:function_handle:nocodegen'); - h = matlabFunction(2*x*y, x+y); - warning(s) - [t1, t2] = h(3,5); - assert(t1 == 30 && t2 == 8) -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@sym/besselyn.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/besselyn.m + syms x w + Pi=sym('pi'); + assert(logical( ifourier(exp(-w^2/4)) == 1/(sqrt(Pi)*exp(x^2)) )) + assert(logical( ifourier(sqrt(Pi)/exp(w^2/4)) == exp(-x^2) )) ***** test - % roundtrip - syms x - A = double(besselyn(sym(2), sym(10))); - q = besselyn(sym(2), x); - h = function_handle(q); - B = h(10); - assert (abs (A - B) <= eps) -***** error yn(sym('x')) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/sympy.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sympy.m -***** assert (strcmp (sympy (sym(pi)), 'pi')) -***** assert (strcmp (sympy (sym(1)), 'Integer(1)')) -***** assert (strcmp (sympy (sym(2)/3), 'Rational(2, 3)')) -***** assert (strcmp (sympy (sym('x')), 'Symbol(''x'')')) + % Dirac delta tests + syms x w + Pi=sym('pi'); + assert(logical( ifourier(dirac(w-2)) == exp(2*1i*x)/(2*Pi) )) + assert (logical( ifourier(sym(2), w, x) == 2*dirac(x) )) ***** test - x = sym('x'); - assert (isequal (sym(sympy(x)), x)) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/logint.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/logint.m -***** error logint (sym(1), 2) + % advanced test + syms x w c d + Pi=sym('pi'); + f=(Pi*(dirac(x-c)+dirac(x+c))+2*Pi*1i*(-dirac(x+3*d)+dirac(x-3*d))+2/(x^2+1))/(2*Pi); + assert(logical( simplify(ifourier(cos(c*w)+2*sin(3*d*w)+exp(-abs(w)))-f) == 0 )) ***** xtest - assert (isequaln (logint (sym(nan)), sym(nan))) + % Inverse Fourier transform cannot recover non-smooth functions + % SymPy cannot evaluate correctly?? + syms x w + assert(logical( ifourier(2/(w^2 + 1)) == exp(-abs(x)) )) + assert(logical( ifourier(2/(w^2 + 1)) == heaviside(x)/exp(x) + heaviside(-x)*exp(x) )) + assert(logical( ifourier(-(w*4)/(w^4 + 2*w^2 + 1) )== -x*exp(-abs(x))*1i )) + assert(logical( ifourier(-(w*4)/(w^4 + 2*w^2 + 1) )== -x*(heaviside(x)/exp(x) + heaviside(-x)*exp(x))*1i )) !!!!! known failure -assert (isequaln (logint (sym (nan)), sym (nan))) failed -***** shared x, d - d = 2; - x = sym('2'); -***** test - f1 = logint(x); - f2 = 1.045163780117492784845; - assert( abs(double(f1) - f2) < 1e-15 ) -***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = logint(A); - f2 = 1.045163780117492784845; - f2 = [f2 f2; f2 f2]; - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) -***** test - % round trip - y = sym('y'); - A = logint (d); - f = logint (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 4 passed, 1 known failure, 0 skipped -[inst/@sym/airy.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/airy.m -***** test - syms z - a = airy(0, z); - ap = airy(1, z); - assert (isequal (diff (a), ap)) - assert (isequal (diff (ap), z*a)) -***** test - syms z - b = airy(2, z); - bp = airy(3, z); - assert (isequal (diff (b), bp)) - assert (isequal (diff (bp), z*b)) +assert (logical (ifourier (2 / (w ^ 2 + 1)) == exp (-abs (x)))) failed +***** error ifourier (sym('k', 'positive')*sym('k')) ***** test - % default to k=0 - syms z - a = airy(0, z); - a2 = airy(z); - assert (isequal (a, a2)) -***** error airy(0, sym('x'), 2) -***** error airy(4, sym('z')) -***** error airy(-1, sym('z')) + % SMT compact, prefers k over symvar + syms k x y + assert (isequal (ifourier(y*exp(-k^2/4)), y/sqrt(sym(pi))*exp(-x^2))) +8 tests, 7 passed, 1 known failure, 0 skipped +[inst/@sym/signIm.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/signIm.m +***** assert (isequal (signIm (sym(1)), sym(0))) +***** assert (isequal (signIm (sym(1) + 2i), sym(1))) +***** assert (isequal (signIm (sym(1) - 2i), sym(-1))) ***** test - % symbolic k + % intermediate A looks bit weird, but it works syms z - b1 = airy(2, z); - b2 = airy(sym(2), z); - assert (isequal (b1, b2)) -***** test - % doubles, relative error - X = [1 2 pi; 4i 5 6+6i]; - Xs = sym(X); - for k = 0:3 - A = double(airy(k, Xs)); - B = airy(k, X); - assert (all (all (abs(A - B) < 500*eps*abs(A)))) - end -***** test - % round-trip - syms x - for k = 0:3 - A = airy(k, 10); - q = airy(k, x); - h = function_handle(q); - B = h(10); - assert (abs(A-B) < 500*eps*abs(A)) - end -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/besselj.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/besselj.m -***** test - X = [1 2 3; 4 5 6]; - ns = [sym(0) 1 -2; sym(1)/2 -sym(3)/2 pi]; - n = double(ns); - A = double(besselj(ns, X)); - B = besselj(n, X); - assert (all (all (abs (A - B) < 50*eps*abs(A)))) -***** test - % roundtrip - syms x - A = besselj(2, 10); - q = besselj(2, x); - h = function_handle(q); - B = h(10); - assert (abs (A - B) <= eps*abs(A)) -***** error besselj(sym('x')) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/fplot.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/fplot.m -***** test - % simple - syms x - f = cos (x); - fplot (f); -warning: using the gnuplot graphics toolkit is discouraged - -The gnuplot graphics toolkit is not actively maintained and has a number -of limitations that are unlikely to be fixed. Communication with gnuplot -uses a one-directional pipe and limited information is passed back to the -Octave interpreter so most changes made interactively in the plot window -will not be reflected in the graphics properties managed by Octave. For -example, if the plot window is closed with a mouse click, Octave will not -be notified and will not update its internal list of open figure windows. -The qt toolkit is recommended instead. -***** test - % constant function - fplot (sym (10)); - line 0: warning: iconv failed to convert degree sign - |--------------------------------------------------------------------| - 1 +|+ + + **** + + +-+| - | + + ** + ** + +-----------------+ | - #|############################*########*##########+***?***x) cos (x)+ | - #|###########################*##########*########################### | - #|##########################*############*########################## | - 0.5 +|+########################*##############*########################+-+| - #|########################*################*######################## | - *|########################*################*######################## *| - #|#######################*##################*#######################* | - #|######################**##################**######################* | - 0 +|*####################*######################*####################*-+| - #|*####################*######################*####################* | - #|#**#################*########################*#################**# | - #|##*#################*########################*#################*## | - #|###*###############*##########################*###############*### | - -0.5 +|+###*#############*############################*#############*###+-+| - #|####**###########*##############################*###########**#### | - #|#####*##########*################################*##########*##### | - #|######**#######*##################################*#######**###### | - #|--------------------------------------------------------------------| - -1 +-+####+###*****#####+#############+############+#####*****###+####+-+ - -4 -2 0 2 4 - -warning: fplot: FCN is not a vectorized function which reduces performance -warning: called from - fplot at line 172 column 7 - fplot at line 107 column 5 - __test__ at line 4 column 2 - test at line 682 column 11 - /tmp/tmp.fXtefQ8zRW at line 1094 column 31 - -***** test - syms x - f = cos (x); - [xx, yy] = fplot (f); - assert (xx(1), -5) - assert (xx(end), 5) - assert (min (yy), -1, 0.1) - assert (max (yy), 1, 0.1) - line 0: warning: iconv failed to convert degree sign - |--------------------------------------------------------------------| - 11 +|+ + + + + + +-+| - | + + + + +------------+ | - #|#####################################################+***?***x) 10+ | - 10.5 +|+################################################################+-+| - #|################################################################## | - #|################################################################## | - #|################################################################## | - 10 *|********************************************************************| - #|################################################################## | - #|################################################################## | - 9.5 +|+################################################################+-+| - #|################################################################## | - #|################################################################## | - 9 +|+################################################################+-+| - #|################################################################## | - #|################################################################## | - #|################################################################## | - 8.5 +|+################################################################+-+| - #|################################################################## | - #|--------------------------------------------------------------------| - 8 +-+####+#############+#############+############+#############+####+-+ - -4 -2 0 2 4 - -***** test - syms x - f = cos (x); - dom = [1 3]; - [xx, yy] = fplot (f, dom); - assert (xx(1), dom(1)) - assert (xx(end), dom(2)) -***** test - syms x - f = cos (x); - dom = [1 3]; - fplot (f, dom); - assert (get (gca, 'xlim'), dom) -***** test - syms x - f = exp (x); - dom = [1 2 3 4]; - fplot (f, dom); - assert (get (gca, 'xlim'), dom(1:2)) - assert (get (gca, 'ylim'), dom(3:4)) - line 0: warning: iconv failed to convert degree sign - |--------------------------------------------------------------------| - 1 +|+ + + + +-+| - +| + + +-----------------++| - #|################################################+***?***x) cos (x)+ | - #|################################################################## | - #|################################################################## | - 0.5 *|**###############################################################+-+| - #|##**############################################################## | - #|####*****######################################################### | - #|#########***###################################################### | - #|############*****################################################# | - 0 +|+################**##############################################+-+| - #|###################*****########################################## | - #|########################***####################################### | - #|###########################**##################################### | - #|#############################*****################################ | - -0.5 +|+#################################*****##########################+-+| - #|#######################################**######################### | - #|#########################################*****#################### | - #|##############################################********############ | - +|--------------------------------------------------------------------| - -1 +-+##############+#################+################+##########******* - 1 1.5 2 2.5 3 - -***** test - % bounds as syms - syms x - f = cos (x); - dom = [1 2 3 4]; - fplot (f, sym (dom)); - assert (get (gca, 'xlim'), dom(1:2)) - assert (get (gca, 'ylim'), dom(3:4)) - line 0: warning: iconv failed to convert degree sign - |---------------------------------------------------------------------| - +| + *+ + + | - +| + * + + +-----------------+ | - #|#######################*#########################+***?***x) exp (x)+ | - #|######################*############################################ | - 3.8 +|+#####################*###########################################+-+| - #|#####################*############################################# | - #|####################*############################################## | - #|###################*############################################### | - 3.6 +|+#################*###############################################+-+| - #|#################*################################################# | - #|################*################################################## | - #|###############*################################################### | - 3.4 +|+############**###################################################+-+| - #|############*###################################################### | - #|###########*####################################################### | - #|##########*######################################################## | - 3.2 +|+########*########################################################+-+| - #|########*########################################################## | - #|######**########################################################### | - +|---------------------------------------------------------------------| - 3 +-+###*#######+#############+#############+#############+###########+-+ - 1 1.2 1.4 1.6 1.8 - -***** test - % bounds as syms, regular handle for function - % fails on 6.1.0, maybe earlier too? - if (compare_versions (OCTAVE_VERSION (), '6.1.0', '!=')) - dom = [1 2]; - fplot (@cos, sym (dom)); - assert (get (gca, 'xlim'), dom(1:2)) - end - line 0: warning: iconv failed to convert degree sign - |---------------------------------------------------------------------| - +| + + + + | - +| + + + +-----------------+ | - #|#################################################+***?***x) cos (x)+ | - #|################################################################### | - 3.8 +|+#################################################################+-+| - #|################################################################### | - #|################################################################### | - #|################################################################### | - 3.6 +|+#################################################################+-+| - #|################################################################### | - #|################################################################### | - #|################################################################### | - 3.4 +|+#################################################################+-+| - #|################################################################### | - #|################################################################### | - #|################################################################### | - 3.2 +|+#################################################################+-+| - #|################################################################### | - #|################################################################### | - +|---------------------------------------------------------------------| - 3 +-+###########+#############+#############+#############+###########+-+ - 1 1.2 1.4 1.6 1.8 - -***** error - syms x y - fplot (x*y) - line 0: warning: iconv failed to convert degree sign - |--------------------------------------------------------------------| - 0.8 +|+ + + + + +-+| - +| + + + + +----------+ | - 0.6 +|+######################################################+***?***cos++| - *|*################################################################# | - #|#*****############################################################ | - 0.4 +|+#####*****######################################################+-+| - #|###########**********############################################# | - 0.2 +|+####################*****#######################################+-+| - #|##########################*****################################### | - #|###############################****############################### | - 0 +|+##################################*****#########################+-+| - #|########################################*****##################### | - -0.2 +|+############################################*****###############+-+| - #|##################################################*****########### | - #|#######################################################**********# | - -0.4 +|+################################################################***| - #|################################################################## | - -0.6 +|+################################################################+-+| - #|################################################################## | - +|--------------------------------------------------------------------| - -0.8 +-+###########+#############+############+#############+###########+-+ - 1 1.2 1.4 1.6 1.8 - -***** test - % N parameter does something - syms x - [xx, yy] = fplot (sin (x), [0 2], 5); - N = length (xx); - assert (N >= 5) - [xx, yy] = fplot (sin (x), [0 2], 1000); - N = length (xx); - assert (N == 1000) -***** test - % tolerance parameter does something - syms x - [xx, yy] = fplot (sin (exp (x/2)), [0 3], 0.1); - N1 = length (xx); - [xx, yy] = fplot (sin (exp (x/2)), [0 3], 0.01); - N2 = length (xx); - assert (N2 > N1) -***** test - % fmt parameter does something - syms x - fplot (sin (x), [0 6], 'rx--', 'linewidth', 5); - l = get (gca (), 'children'); - assert (get (l, 'color'), [1 0 0]) - assert (get (l, 'linewidth'), 5) - f = exp (x); - dom = [1 2 3 4]; - fplot (f, dom); - assert (get (gca, 'xlim'), dom(1:2)) - assert (get (gca, 'ylim'), dom(3:4)) - line 0: warning: iconv failed to convert degree sign - |--------------------------------------------------------------------| - 1 +|+ + BBBB*BB + + + + +-+| - +| B*B BB + + +-----------------++| - #|########BB############*BB#######################+***B***x) sin (x)+ | - #|######*B#################B######################################## | - #|#####B####################B####################################### | - 0.5 +|+###B######################*B####################################+-+| - #|###B#########################B#################################### | - #|#*B###########################B################################### | - #|B##############################B################################## | - #|################################*B################################ | - 0 B|+#################################B##############################+-+| - #|###################################B############################## | - #|####################################B############################# | - #|#####################################B############################ B| - #|######################################*B##########################B | - -0.5 +|+#######################################B#######################*B-+| - #|#########################################B#####################B## | - #|##########################################B*B################BB### | - #|#############################################B#############*B##### | - +|--------------------------------------------------------------------| - -1 +-+#########+##########+###########+##########+#####BBBB*B+########+-+ - 0 1 2 3 4 5 6 - -***** test - close all -13 tests, 13 passed, 0 known failure, 0 skipped -[inst/@sym/triu.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/triu.m -***** test - % scalar - syms x - assert (isequal (triu(x), x)) - assert (isequal (triu(x,0), x)) - assert (isequal (triu(x,1), 0)) - assert (isequal (triu(x,-1), 0)) -***** test - % with symbols - syms x - A = [x 2*x; 3*x 4*x]; - assert (isequal (triu(A), [x 2*x; 0 4*x])) -***** test - % diagonal shifts - B = round(10*rand(3,4)); - A = sym(B); - assert (isequal (triu(A), triu(B))) - assert (isequal (triu(A,0), triu(B,0))) - assert (isequal (triu(A,1), triu(B,1))) - assert (isequal (triu(A,-1), triu(B,-1))) -***** test - % double array pass through - B = round(10*rand(3,4)); - assert (isequal (triu(B,sym(1)), triu(B,1))) - assert (isa (triu(B,sym(1)), 'double')) -***** test - % immutable test - A = sym('ImmutableDenseMatrix([[Integer(1), Integer(2)], [Integer(3), Integer(4)]])'); - assert (isequal (triu (A), sym ([1 2; 0 4]))) - assert (isequal (tril (A), sym ([1 0; 3 4]))) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/sinint.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sinint.m -***** error sinint (sym(1), 2) -***** xtest - assert (isequaln (sinint (sym(nan)), sym(nan))) -!!!!! known failure -assert (isequaln (sinint (sym (nan)), sym (nan))) failed -***** shared x, d - d = 1; - x = sym('1'); -***** test - f1 = sinint(x); - f2 = 0.9460830703671830149414; - assert( abs(double(f1) - f2) < 1e-15 ) -***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = sinint(A); - f2 = 0.9460830703671830149414; - f2 = [f2 f2; f2 f2]; - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) -***** test - % round trip - y = sym('y'); - A = sinint (d); - f = sinint (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -***** test - % rewrite - syms x - y1 = sinint (x); - y2 = rewrite (y1, 'Integral'); - d1 = diff (y1, x); - d2 = diff (y2, x); - v1 = double (subs (d1, x, 2)); - v2 = double (subs (d2, x, 2)); - assert (v1, v2, -eps) -6 tests, 5 passed, 1 known failure, 0 skipped -[inst/@sym/fix.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/fix.m -***** test - d = 3/2; - x = sym('3/2'); - f1 = fix(x); - f2 = fix(d); - assert (isequal (f1, f2)) -***** test - D = [1.1 4.6; -3.4 -8.9]; - A = [sym(11)/10 sym(46)/10; sym(-34)/10 sym(-89)/10]; - f1 = fix(A); - f2 = fix(D); - assert( isequal (f1, f2)) -***** test - d = sym(-11)/10; - c = -1; - assert (isequal (fix (d), c)) -***** test - d = sym(-19)/10; - c = -1; - assert (isequal (fix (d), c)) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/findsym.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/findsym.m -***** assert (strcmp (findsym (sym(2)), '')); -***** shared x,y,f - x=sym('x'); y=sym('y'); f=x^2+3*x*y-y^2; -***** assert (strcmp (findsym (f), 'x,y')); -***** assert (strcmp (findsym (f,1), 'x')); -***** test - % test order of returned vars - syms x y a b c xx - % https://www.mathworks.com/matlabcentral/newsreader/view_thread/237730 - alpha = sym('alpha'); - assert (strcmp (findsym(b*xx*exp(alpha) + c*sin(a*y), 2), 'xx,y')) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/interval.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/interval.m -***** test - a = interval(sym(1), 2); - assert (isa (a, 'sym')) -***** test - % some set subtraction - a = interval(sym(0), 4); - b = interval(sym(0), 1); - c = interval(sym(1), 4, true); - q = a - b; - assert (isequal( q, c)) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/int.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/int.m -***** shared x,y,a - syms x y a -***** assert(logical(int(cos(x)) - sin(x) == 0)) -***** assert(logical(int(cos(x),x) - sin(x) == 0)) -***** assert(logical(int(cos(x),x,0,1) - sin(sym(1)) == 0)) -***** test - %% limits might be syms - assert( isequal (int(cos(x),x,sym(0),sym(1)), sin(sym(1)))) - assert( isequal (int(cos(x),x,0,a), sin(a))) -***** test - %% other variables present - assert( isequal (int(y*cos(x),x), y*sin(x))) -***** test - %% limits as array - assert( isequal (int(cos(x),x,[0 1]), sin(sym(1)))) - assert( isequal (int(cos(x),x,sym([0 1])), sin(sym(1)))) - assert( isequal (int(cos(x),x,[0 a]), sin(a))) -***** test - %% no x given - assert( isequal (int(cos(x),[0 1]), sin(sym(1)))) - assert( isequal (int(cos(x),sym([0 1])), sin(sym(1)))) - assert( isequal (int(cos(x),[0 a]), sin(a))) - assert( isequal (int(cos(x),0,a), sin(a))) -***** test - %% integration of const - assert( isequal (int(sym(2),y), 2*y)) - assert( isequal (int(sym(2)), 2*x)) - assert( isequal (int(sym(2),[0 a]), 2*a)) - assert( isequal (int(sym(2),0,a), 2*a)) -***** test - % componentwise int of array - A = [x x*x]; - assert (isequal (int(A, x), [x^2/2 x^3/3])) -***** test - % NonElementaryIntegral bug - % https://savannah.gnu.org/bugs/index.php?46831 - f = int(exp(exp(x))); - f = f + 2; - g = diff(f); - assert (isequal (g, exp(exp(x)))) -10 tests, 10 passed, 0 known failure, 0 skipped -[inst/@sym/transpose.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/transpose.m -***** test - x = sym(1); - assert (isequal (x.', x)) -***** assert (isempty (sym([]).')) -***** test - syms x; - assert (isequal (x.', x)) -***** test - A = [1 2; 3 4]; - assert(isequal( sym(A).' , sym(A.') )) + A = signIm (z); + assert (isequal (subs(A, z, 3+sym(4i)), sym(1))) + assert (isequal (subs(A, z, 3-sym(4i)), sym(-1))) ***** test - A = [1 2] + 1i; - assert(isequal( sym(A).' , sym(A.') )) + % really a @sym/sign test, but that one is autogen + z = 3 + sym(4i); + A = sign (z); + B = z / abs(z); + assert (double (A), double (B), eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/det.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/det.m -***** assert (isequal (det(sym([])), 1)) -***** test - syms x y real - assert (isequal (det([x 5; 7 y]), x*y-35)) -***** test - syms x - assert (isequal (det(x), x)) - assert (isequal (det(sym(-6)), sym(-6))) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/ezcontour.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ezcontour.m -***** error - syms x y z - ezcontour (x*y*z) -1 test, 1 passed, 0 known failure, 0 skipped [inst/@sym/ilaplace.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ilaplace.m ***** error ilaplace (sym(1), 2, 3, 4) @@ -8082,2566 +10141,1006 @@ syms x t assert (isequal (ilaplace (x/s^2, t), x*t*heaviside(t))) 11 tests, 11 passed, 0 known failure, 0 skipped -[inst/@sym/isfinite.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isfinite.m -***** assert (isfinite(sym(1))) -***** assert (isfinite(sym(-10))) -***** assert (~isfinite(sym('oo'))) -***** assert (~isfinite(sym('-oo'))) -***** assert (~isfinite(sym(1)/0)) -***** assert (~isfinite(sym(nan))) -***** assert (isequal (isfinite (sym ([1 inf])), [true false])) -***** test - % finite-by-assumption - syms x finite - assert (isfinite (x)) -8 tests, 8 passed, 0 known failure, 0 skipped -[inst/@sym/erfi.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/erfi.m -***** error erfi (sym(1), 2) -***** assert (isequaln (erfi (sym(nan)), sym(nan))) -***** shared x, d - d = 0; - x = sym('0'); -***** test - f1 = erfi(x); - f2 = 0; - assert( abs(double(f1) - f2) < 1e-15 ) +[inst/@sym/toeplitz.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/toeplitz.m ***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = erfi(A); - f2 = 0; - f2 = [f2 f2; f2 f2]; - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) + % rect + R = [10 20 40]; C = [10 30]; + A = sym(toeplitz(R,C)); + B = toeplitz(sym(R),sym(C)); + assert (isequal (A, B)) + R = [10 20]; C = [10 30 50]; + A = sym(toeplitz(R,C)); + B = toeplitz(sym(R),sym(C)); + assert (isequal (A, B)) ***** test - % round trip - y = sym('y'); - A = erfi (d); - f = erfi (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/mrdivide.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/mrdivide.m + % symbols + syms x y + R = [10 20 40]; C = [10 30]; + Rs = [10 x 40]; Cs = [10 y]; + A = toeplitz(R,C); + B = toeplitz(Rs,Cs); + assert (isequal (A, subs(B,[x,y],[20 30]))) ***** test - % scalar + % hermitian + syms a b c + A = [a b c; conj(b) a b; conj(c) conj(b) a]; + B = toeplitz([a,b,c]); + assert (isequal( A, B)) +***** warning + % mismatch syms x - assert (isa( x/x, 'sym')) - assert (isequal( x/x, sym(1))) - assert (isa( 2/x, 'sym')) - assert (isa( x/2, 'sym')) -***** test - % matrix / scalar - D = 2*[0 1; 2 3]; - A = sym(D); - assert (isequal ( A/2 , D/2 )) - assert (isequal ( A/sym(2) , D/2 )) -***** test - % I/A: either invert A or leave unevaluated: not bothered which - A = sym([1 2; 3 4]); - B = sym(eye(2)) / A; - assert (isequal (B, inv(A)) || strncmpi (sympy (B), 'MatPow', 6)) -***** xtest - % immutable test, upstream: TODO - A = sym([1 2; 3 4]); - B = sym('ImmutableDenseMatrix([[Integer(1), Integer(2)], [Integer(3), Integer(4)]])'); - assert (isequal (A/A, B/B)) -***** test - % A = C/B is C = A*B - A = sym([1 2; 3 4]); - B = sym([1 3; 4 8]); - C = A*B; - A2 = C / B; - assert (isequal (A, A2)) -***** test - A = [1 2; 3 4]; - B = A / A; - % assert (isequal (B, sym(eye(2)) - assert (isequal (B(1,1), 1)) - assert (isequal (B(2,2), 1)) - assert (isequal (B(2,1), 0)) - assert (isequal (B(1,2), 0)) -***** test - A = sym([5 6]); - B = sym([1 2; 3 4]); - C = A*B; - A2 = C / B; - assert (isequal (A, A2)) -7 tests, 7 passed, 0 known failure, 0 skipped -[inst/@sym/ellipticE.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipticE.m -***** error ellipticE (sym(1), 2, 3) -***** assert (double (ellipticE (sym (-105)/10)), 3.70961391, 10e-9) -***** assert (double (ellipticE (sym (-pi)/4)), 1.844349247, 10e-10) -***** assert (double (ellipticE (sym (0))), 1.570796327, 10e-10) -***** assert (double (ellipticE (sym (1))), 1, 10e-1) -***** test - % compare to Maple - us = vpa (ellipticE (sym(7)/6, sym(13)/7), 40); - % > evalf(EllipticE(sin(7/6), sqrt(13/7)), 40); - maple = vpa ('0.6263078268598504591831743625971763209496', 40) + ... - vpa ('0.1775496232203171126975790989055865596501j', 40); - assert (abs (double (maple - us)), 0, 2e-39) -***** test - % compare to Maple - us = vpa (ellipticE (sym(8)/7), 40); - % > evalf(EllipticE(sqrt(8/7)), 40); - maple = vpa ('0.8717182992576322508542205614105802333270', 40) + ... - vpa ('0.1066754320328976949531350910798010526685j', 40); - assert (abs (double (maple - us)), 0, 2e-39) -7 tests, 7 passed, 0 known failure, 0 skipped -[inst/@sym/ismember.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ismember.m -***** assert (ismember (2, interval(sym(0),2))) -***** assert (~ismember (3, interval(sym(0),2))) + B = toeplitz([10 x], [1 3 x]); +***** warning + % scalar + B = toeplitz(sym(2), 3); + assert (isequal (B, sym(2))) ***** test - % something in a matrix - syms x - A = [1 x; sym(pi) 4]; - assert (ismember (sym(pi), A)) - assert (ismember (x, A)) - assert (~ismember (2, A)) + % mismatch + syms x y + fprintf('\n one warning expected\n') % how to quiet this one? + A = toeplitz([10 2], [1 3 5]); + s = warning ('off', 'OctSymPy:toeplitz:diagconflict'); + B = toeplitz([10 x], [1 3 y]); + warning(s) + assert (isequal (A, subs(B, [x,y], [2 5]))) + + one warning expected +warning: toeplitz: column wins diagonal conflict +warning: called from + toeplitz at line 84 column 7 + __test__ at line 6 column 4 + test at line 682 column 11 + /tmp/tmp.wlPrNg8GOU at line 1430 column 31 + +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@sym/tril.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/tril.m ***** test - % set syms x - S = finiteset(2, sym(pi), x); - assert (ismember (x, S)) -***** test - % set with positive symbol - syms p positive - S = finiteset(2, sym(pi), p); - assert (~ismember (-1, S)) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/argnames.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/argnames.m + assert (isequal (tril(x), x)) ***** test - % basic tests + % with symbols syms x - f = 2*x; - assert (isempty (argnames(x))) - assert (isempty (argnames(f))) -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@sym/atand.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/atand.m -***** error atand (sym(1), 2) -***** assert (isequaln (atand (sym(nan)), sym(nan))) + A = [x 2*x; 3*x 4*x]; + assert (isequal (tril(A), [x 0; 3*x 4*x])) ***** test - f1 = atand (sym(1)/2); - f2 = atand (1/2); - assert (double (f1), f2, -eps) + % diagonal shifts + B = round(10*rand(3,4)); + A = sym(B); + assert (isequal (tril(A), tril(B))) + assert (isequal (tril(A,0), tril(B,0))) + assert (isequal (tril(A,1), tril(B,1))) + assert (isequal (tril(A,-1), tril(B,-1))) ***** test - D = [1 2; 3 4]/4; - A = sym([1 2; 3 4])/4; - f1 = atand (A); - f2 = atand (D); - assert (double (f1), f2, -eps) + % double array pass through + B = round(10*rand(3,4)); + assert (isequal (tril(B,sym(1)), tril(B,1))) + assert (isa (tril(B,sym(1)), 'double')) 4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/colon.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/colon.m -***** test - a = sym(1):5; - b = sym(1:5); - assert(isequal(a,b)); - a = 1:sym(5); - b = sym(1:5); - assert(isequal(a,b)); -***** test - a = 2:sym(2):8; - b = sym(2:2:8); - assert(isequal(a,b)); -***** test - a = sym(10):-2:-4; - b = sym(10:-2:-4); - assert(isequal(a,b)); -***** test - % symbolic intervals - p = sym(pi); - L = 0:p/4:p; - assert(isa(L,'sym')); - assert(isequal(L, [0 p/4 p/2 3*p/4 p])); -***** test - % mixed symbolic and double intervals - p = sym(pi); - s = warning ('off', 'OctSymPy:sym:rationalapprox'); - L = 0.1:(sym(pi)/3):2.3; - warning(s) - assert(isa(L,'sym')); - t = sym(1)/10; - assert(isequal(L, [t p/3+t 2*p/3+t])); -***** error syms x; a = 0:x; -***** error syms x; a = 1:x; -7 tests, 7 passed, 0 known failure, 0 skipped -[inst/@sym/double.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/double.m -***** test - % numeric scalar - a = double(sym(10)); - assert (a == 10) - assert (isa (a, 'double')) -***** test - % numeric vectors - a = double(sym([10 12])); - assert (isequal (a, [10 12])) - assert (isa (a, 'double')) -***** test - % complex - a = 3 + 4i; - b = sym(a); - assert (isequal (double (b), a)) -***** xtest - % unexpected, precisely same floating point - a = 3 + 4i; - b = sym(a); - assert (isequal (double (b/pi), a/pi)) -***** test - % floating point - x = sqrt(sym(2)); - assert( abs(double(x) - sqrt(2)) < 2*eps) - x = sym(pi); - assert( abs(double(x) - pi) < 2*eps) +[inst/@sym/ipermute.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ipermute.m +***** error permute (sym(1)) +***** error permute (sym(1), 2, 3) ***** test - oo = sym(inf); - assert( double(oo) == inf ) - assert( double(-oo) == -inf ) - assert( isnan(double(0*oo)) ) + syms x + A = [1 x]; + perm = [2 1]; + B = permute(A, perm); + C = ipermute(B, perm); + assert (isequal(C, A)) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/jacobian.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/jacobian.m +***** error jacobian (sym(1), 2, 3) +***** error jacobian ([sym(1) 2; sym(3) 4]) +***** shared x,y,z + syms x y z ***** test - zoo = sym('zoo'); - assert (double(zoo) == complex(inf, inf)) + % 1D + f = x^2; + assert (isequal (jacobian(f), diff(f,x))) + assert (isequal (jacobian(f,{x}), diff(f,x))) + assert (isequal (jacobian(f,x), diff(f,x))) ***** test - zoo = sym('zoo'); - assert (double(-zoo) == double(zoo) ) - assert( isnan(double(0*zoo)) ) + % const + f = sym(1); + g = sym(0); + assert (isequal (jacobian(f), g)) + assert (isequal (jacobian(f,x), g)) ***** test - % nan - snan = sym(nan); - assert( isnan(double(snan))) + % double const + f = 1; + g = sym(0); + assert (isequal (jacobian(f,x), g)) ***** test - % don't want NaN+NaNi - snan = sym(nan); - assert (isreal (double (snan))) + % diag + f = [x y^2]; + g = [sym(1) 0; 0 2*y]; + assert (isequal (jacobian(f), g)) + assert (isequal (jacobian(f, [x y]), g)) + assert (isequal (jacobian(f, {x y}), g)) ***** test - % arrays - a = [1 2; 3 4]; - assert( isequal( double(sym(a)), a )) - assert( isequal( double(sym(a)), a )) - % should fail with error for non-double -***** error syms x; double(x) -***** error syms x; double([1 2 x]) -13 tests, 13 passed, 0 known failure, 0 skipped -[inst/@sym/orth.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/orth.m + % anti-diag + f = [y^2 x]; + g = [0 2*y; sym(1) 0]; + assert (isequal (jacobian(f), g)) + assert (isequal (jacobian(f, {x y}), g)) ***** test - A = [1 2; 3 6]; - K = orth(A); - L = orth(sym(A)); - assert (isequal (size(L), [2 1])) - dif1 = abs (double(L) - K); - dif2 = abs (double(L) + K); - assert (all (dif1 < 1e-15) || all (dif2 < 1e-15)) + % shape + f = [x y^2]; + assert (isequal (size(jacobian(f, {x y z})), [2 3])) + assert (isequal (size(jacobian(f, [x y z])), [2 3])) + assert (isequal (size(jacobian(f, [x; y; z])), [2 3])) + assert (isequal (size(jacobian(f.', {x y z})), [2 3])) ***** test - A = [1; 3]; - K = orth(A); - L = orth(sym(A)); - assert (isequal (size(L), [2 1])) - dif1 = abs (double(L) - K); - dif2 = abs (double(L) + K); - assert (all (dif1 < 1e-16) || all (dif2 < 1e-16)) + % scalar f + f = x*y; + assert (isequal (size(jacobian(f, {x y})), [1 2])) + g = gradient(f, {x y}); + assert (isequal (jacobian(f, {x y}), g.')) ***** test - A = sym([1 2; 3 4]); - L = orth(sym(A)); - assert (isequal (size(L), [2 2])) - v = L(:, 1); - w = L(:, 2); - assert (isAlways (v' * v == 1)) - assert (isAlways (w' * w == 1)) - assert (isAlways (v' * w == 0)) + % vect f wrt 1 var + f = [x x^2]; + assert (isequal (size(jacobian(f, x)), [2 1])) + f = f.'; % same shape output + assert (isequal (size(jacobian(f, x)), [2 1])) +10 tests, 10 passed, 0 known failure, 0 skipped +[inst/@sym/isna.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isna.m ***** test - A = sym([1 1; 1 0; 1 0]); - L = orth(sym(A)); - assert (isequal (size(L), [3 2])) - v = L(:, 1); - w = L(:, 2); - assert (isAlways (v' * v == 1)) - assert (isAlways (w' * w == 1)) - assert (isAlways (v' * w == 0)) - % y and z components must be equal - assert (isAlways (v(2) == v(3))) - assert (isAlways (w(2) == w(3))) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/lambertw.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/lambertw.m + % no sym should be NA + syms x oo + assert (~isna(sym(1))) + assert (~isna(x)) + assert (~isna(oo)) + assert (~isna(sym(nan))) + assert (isequal (isna (sym ([1 nan])), [false false])) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@sym/taylor.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/taylor.m ***** test - % W(x)*exp(W(x)) == x syms x - T = lambertw(x)*exp(lambertw(x)); - T = double (subs (T, x, 10)); - assert (isequal (T, 10)); + f = exp(x); + expected = 1 + x + x^2/2 + x^3/6 + x^4/24 + x^5/120; + assert (isequal (taylor(f), expected)) + assert (isequal (taylor(f,x), expected)) + assert (isequal (taylor(f,x,0), expected)) ***** test - % k, x not x, k to match SMT - syms x - T = lambertw(2, x)*exp(lambertw(2, x)); - T = double (subs (T, x, 10)); - assert (abs(T - 10) < 1e-15) -***** assert (isequal (lambertw(sym(0)), sym(0))) -***** assert ( isequal (lambertw (-1/exp(sym(1))), -sym(1))) -***** assert ( isequal (lambertw (0, -1/exp(sym(1))), -sym(1))) -***** assert ( isequal (lambertw (-1, -1/exp(sym(1))), -sym(1))) -***** xtest - % W(x)*exp(W(x)) == x; FIXME: a failure in SymPy? syms x - T = simplify(lambertw(x)*exp(lambertw(x))); - assert (isequal (T, x)) -!!!!! known failure -assert (isequal (T, x)) failed -***** assert (abs (lambertw(pi) - double(lambertw(sym(pi)))) < 5*eps) -***** assert (abs (lambertw(-1, 5) - double(lambertw(-1, sym(5)))) < 5*eps) -***** assert (abs (lambertw(2, 2) - double(lambertw(2, sym(2)))) < 5*eps) -***** test - % round trip - syms x k - A = lambertw (5); - f = lambertw (x); - h = function_handle (f); - B = h (5); - assert (A, B) - - A = lambertw (3, 5); - f = lambertw (k, x); - h = function_handle (f); - B = h (3, 5); - assert (A, B) -11 tests, 10 passed, 1 known failure, 0 skipped -[inst/@sym/dsolve.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/dsolve.m -***** error dsolve (1, sym('x')) -***** test - syms y(x) - de = diff(y, 2) - 4*y == 0; - f = dsolve(de); - syms C1 C2 - g1 = C1*exp(-2*x) + C2*exp(2*x); - g2 = C2*exp(-2*x) + C1*exp(2*x); - assert (isequal (f, g1) || isequal (f, g2)) -***** test - % Not enough initial conditions - syms y(x) C1 - de = diff(y, 2) + 4*y == 0; - g = 3*cos(2*x) + C1*sin(2*x); - try - f = dsolve(de, y(0) == 3); - waserr = false; - catch - waserr = true; - expectederr = regexp (lasterr (), 'Perhaps.*under-specified'); - f = 42; - end - assert ((waserr && expectederr) || isequal (f, g)) -***** test - % Solution in implicit form - syms y(x) C1 - de = (2*x*y(x) - exp(-2*y(x)))*diff(y(x), x) + y(x) == 0; - sol = dsolve (de); - eqn = x*exp(2*y(x)) - log(y(x)) == C1; - % could differ by signs - sol = lhs (sol) - rhs (sol); - eqn = lhs (eqn) - rhs (eqn); - sol2 = subs (sol, C1, -C1); - assert (isequal (sol, eqn) || isequal (sol2, eqn)) -***** test - % Compute solution and classification - syms y(x) C1 - de = (2*x*y(x) - exp(-2*y(x)))*diff(y(x), x) + y(x) == 0; - [sol, classy] = dsolve (de); - assert (any (strcmp (classy, '1st_exact'))) -***** test - % initial conditions (first order ode) - syms y(x) - de = diff(y, x) + 4*y == 0; - f = dsolve(de, y(0) == 3); - g = 3*exp(-4*x); - assert (isequal (f, g)) -***** test - % initial conditions (second order ode) - syms y(x) - de = diff(y, 2) + 4*y == 0; - f = dsolve(de, y(0) == 3, subs(diff(y,x),x,0)==0); - g = 3*cos(2*x); - assert (isequal (f, g)) -***** test - % Dirichlet boundary conditions (second order ode) - syms y(x) - de = diff(y, 2) + 4*y == 0; - f = dsolve(de, y(0) == 2, y(1) == 0); - g = -2*sin(2*x)/tan(sym('2'))+2*cos(2*x); - assert (isequal (simplify (f - g), 0)) -***** test - % Neumann boundary conditions (second order ode) - syms y(x) - de = diff(y, 2) + 4*y == 0; - f = dsolve(de, subs(diff(y,x),x,0)==1, subs(diff(y,x),x,1)==0); - g = sin(2*x)/2+cos(2*x)/(2*tan(sym('2'))); - assert (isequal (simplify (f - g), 0)) -***** test - % Dirichlet-Neumann boundary conditions (second order ode) - syms y(x) - de = diff(y, 2) + 4*y == 0; - f = dsolve(de, y(0) == 3, subs(diff(y,x),x,1)==0); - g = 3*sin(2*x)*tan(sym('2'))+3*cos(2*x); - assert (isequal (simplify (f - g), 0)) -***** test - % System of ODEs gives struct, Issue #1003. - syms x(t) y(t) - ode1 = diff(x(t),t) == 2*y(t); - ode2 = diff(y(t),t) == 2*x(t); - soln = dsolve([ode1, ode2]); - assert (isstruct (soln)) - assert (numfields (soln) == 2) - assert (isequal (sort (fieldnames (soln)), {'x'; 'y'})) -***** test - % System of ODEs - syms x(t) y(t) C1 C2 - ode1 = diff(x(t),t) == 2*y(t); - ode2 = diff(y(t),t) == 2*x(t); - soln = dsolve([ode1, ode2]); - soln = [soln.x, soln.y]; - g1 = [C1*exp(-2*t) + C2*exp(2*t), -C1*exp(-2*t) + C2*exp(2*t)]; - g2 = [C1*exp(2*t) + C2*exp(-2*t), C1*exp(2*t) - C2*exp(-2*t)]; - g3 = [-C1*exp(-2*t) + C2*exp(2*t), C1*exp(-2*t) + C2*exp(2*t)]; - g4 = [C1*exp(2*t) - C2*exp(-2*t), C1*exp(2*t) + C2*exp(-2*t)]; - % old SymPy <= 1.5.1 had some extra twos - g5 = [2*C1*exp(-2*t) + 2*C2*exp(2*t), -2*C1*exp(-2*t) + 2*C2*exp(2*t)]; - g6 = [2*C1*exp(2*t) + 2*C2*exp(-2*t), 2*C1*exp(2*t) - 2*C2*exp(-2*t)]; - assert (isequal (soln, g1) || isequal (soln, g2) || ... - isequal (soln, g3) || isequal (soln, g4) || ... - isequal (soln, g5) || isequal (soln, g6)) -***** test - % System of ODEs (initial-value problem) - syms x(t) y(t) - ode_1=diff(x(t),t) == 2*y(t); - ode_2=diff(y(t),t) == 2*x(t); - sol_ivp=dsolve([ode_1,ode_2],x(0)==1,y(0)==0); - g_ivp=[exp(-2*t)/2+exp(2*t)/2,-exp(-2*t)/2+exp(2*t)/2]; - assert (isequal ([sol_ivp.x, sol_ivp.y], g_ivp)) -***** test - syms y(x) - de = diff(y, 2) + 4*y == 0; - f = dsolve(de, y(0) == 0, y(sym(pi)/4) == 1); - g = sin(2*x); - assert (isequal (f, g)) -***** test - % Nonlinear example - syms y(x) C1 - e = diff(y, x) == y^2; - g = -1 / (C1 + x); - soln = dsolve(e); - assert (isequal (soln, g)) -***** test - % Nonlinear example with initial condition - syms y(x) - e = diff(y, x) == y^2; - g = -1 / (x - 1); - soln = dsolve(e, y(0) == 1); - assert (isequal (soln, g)) -***** test - % forcing, Issue #183, broken in older sympy - if (pycall_sympy__ ('return Version(spver) >= Version("1.7.1")')) - syms x(t) y(t) - ode1 = diff(x) == x + sin(t) + 2; - ode2 = diff(y) == y - t - 3; - soln = dsolve([ode1 ode2], x(0) == 1, y(0) == 2); - X = soln.x; - Y = soln.y; - assert (isequal (diff(X) - (X + sin(t) + 2), 0)) - assert (isequal (diff(Y) - (Y - t - 3), 0)) - end -***** test - syms f(x) a b - de = diff(f, x) == 4*f; - s = dsolve(de, f(a) == b); - assert (isequal (subs(s, x, a), b)) -***** test - % array of ICs - syms x(t) y(t) - ode_1 = diff (x(t), t) == 2*y(t); - ode_2 = diff (y(t), t) == 2*x(t); - sol = dsolve([ode_1, ode_2], [x(0)==1 y(0)==0]); - g = [exp(-2*t)/2+exp(2*t)/2, -exp(-2*t)/2+exp(2*t)/2]; - assert (isequal ([sol.x, sol.y], g)) -***** test - % cell-array of ICs or ODEs, but not both - % Note: to support both we'd need a wrapper outside of @sym - syms x(t) y(t) - ode_1 = diff (x(t), t) == 2*y(t); - ode_2 = diff (y(t), t) == 2*x(t); - sol = dsolve([ode_1, ode_2], {x(0)==1 y(0)==0}); - g = [exp(-2*t)/2+exp(2*t)/2, -exp(-2*t)/2+exp(2*t)/2]; - assert (isequal ([sol.x, sol.y], g)) - sol = dsolve({ode_1, ode_2}, [x(0)==1 y(0)==0]); - g = [exp(-2*t)/2+exp(2*t)/2, -exp(-2*t)/2+exp(2*t)/2]; - assert (isequal ([sol.x, sol.y], g)) + f = exp(x); + expected = 1 + x + x^2/2 + x^3/6 + x^4/24; + assert (isequal (taylor(f,'order',5), expected)) + assert (isequal (taylor(f,x,'order',5), expected)) + assert (isequal (taylor(f,x,0,'order',5), expected)) ***** test - % array of ICs, Issue #1040. - if (pycall_sympy__ ('return Version(spver) >= Version("1.7.1")')) - syms x(t) y(t) z(t) - syms x_0 y_0 z_0 - diffEqns = [diff(x, t) == -x + 1, diff(y, t) == -y, diff(z, t) == -z]; - initCond = [x(0) == x_0, y(0) == y_0, z(0) == z_0]; - soln = dsolve (diffEqns, initCond); - soln = [soln.x, soln.y, soln.z]; - exact_soln = [(x_0 - 1)*exp(-t) + 1 y_0*exp(-t) z_0*exp(-t)]; - assert (isequal (soln, exact_soln)) - end -21 tests, 21 passed, 0 known failure, 0 skipped -[inst/@sym/power.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/power.m + % key/value ordering doesn't matter + syms x + f = exp(x); + g1 = taylor(f, 'expansionPoint', 1, 'order', 3); + g2 = taylor(f, 'order', 3, 'expansionPoint', 1); + assert (isequal (g1, g2)) ***** test - % scalar .^ scalar syms x - assert (isa (x.^2, 'sym')) - assert (isa (2.^x, 'sym')) - assert (isa (x.^x, 'sym')) - assert (isequal (x.^2, x^2)) - assert (isequal (2.^x, 2^x)) - assert (isequal (x.^x, x^x)) + f = x^2; + assert (isequal (taylor(f,x,0,'order',0), 0)) + assert (isequal (taylor(f,x,0,'order',1), 0)) + assert (isequal (taylor(f,x,0,'order',2), 0)) + assert (isequal (taylor(f,x,0,'order',3), x^2)) + assert (isequal (taylor(f,x,0,'order',4), x^2)) ***** test - % scalar .^ matrix - D = [0 1; 2 3]; - A = sym(D); - assert (isequal ( sym(2).^D , 2.^D )) - assert (isequal ( sym(2).^A , 2.^A )) - assert (isequal ( 2.^D , 2.^A )) - assert (isequal ( 2.^A , 2.^A )) + syms x y + f = exp(x)+exp(y); + expected = 2 + x + x^2/2 + x^3/6 + x^4/24 + y + y^2/2 + y^3/6 + y^4/24; + assert (isAlways(taylor(f,[x,y],'order',5)== expected)) + assert (isAlways(taylor(f,[x,y],[0,0],'order',5) == expected)) ***** test - % matrix .^ matrix + % key/value ordering doesn't matter syms x - A = [x 2*x; 3*x 4*x]; - D = [0 1; 2 3]; - B = sym(D); - assert (isequal ( A.^D, [1 2*x; 9*x^2 64*x^3] )) - assert (isequal ( A.^B, [1 2*x; 9*x^2 64*x^3] )) + f = exp(x); + g1 = taylor(f, 'expansionPoint', 1, 'order', 3); + g2 = taylor(f, 'order', 3, 'expansionPoint', 1); + assert (isequal (g1, g2)) ***** test - % matrix .^ scalar syms x - A = [x 2*x]; - assert (isequal ( A.^2, [x^2 4*x^2] )) - assert (isequal ( A.^sym(2), [x^2 4*x^2] )) -***** test - % 1^oo - % (sympy >= 0.7.5 gives NaN, SMT R2013b: gives 1) - oo = sym(inf); - assert (isnan (1^oo)) -***** test - % 1^zoo - % (1 on sympy 0.7.4--0.7.6, but nan in git (2014-12-12, a210908d4)) - zoo = sym('zoo'); - assert (isnan (1^zoo)) -***** test - % immutable test - A = sym([1 2]); - B = sym('ImmutableDenseMatrix([[Integer(1), Integer(2)]])'); - assert (isequal (A.^A, B.^B)) -7 tests, 7 passed, 0 known failure, 0 skipped -[inst/@sym/acsc.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/acsc.m -***** error acsc (sym(1), 2) -***** assert (isequaln (acsc (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); -***** test - f1 = acsc(x); - f2 = acsc(d); - assert( abs(double(f1) - f2) < 1e-15 ) -***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = acsc(A); - f2 = acsc(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) -***** test - % round trip - y = sym('y'); - A = acsc (d); - f = acsc (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/atan.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/atan.m -***** error atan (sym(1), 2) -***** assert (isequaln (atan (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); + f = x^2; + assert (isequal (taylor(f,x,0,'order',0), 0)) + assert (isequal (taylor(f,x,0,'order',1), 0)) + assert (isequal (taylor(f,x,0,'order',2), 0)) + assert (isequal (taylor(f,x,0,'order',3), x^2)) + assert (isequal (taylor(f,x,0,'order',4), x^2)) ***** test - f1 = atan(x); - f2 = atan(d); - assert( abs(double(f1) - f2) < 1e-15 ) + % syms for a and order + syms x + f = x^2; + assert (isequal (taylor(f,x,sym(0),'order',sym(2)), 0)) + assert (isequal (taylor(f,x,sym(0),'order',sym(4)), x^2)) ***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = atan(A); - f2 = atan(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) + syms x y + f = exp (x^2 + y^2); + expected = 1+ x^2 +y^2 + x^4/2 + x^2*y^2 + y^4/2; + assert (isAlways(taylor(f,[x,y],'order',5)== expected)) + assert (isAlways(taylor(f,[x,y],'expansionPoint', [0,0],'order',5) == expected)) ***** test - % round trip - y = sym('y'); - A = atan (d); - f = atan (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/setdiff.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/setdiff.m + syms x y + f = sqrt(1+x^2+y^2); + expected = 1+ x^2/2 +y^2/2 - x^4/8 - x^2*y^2/4 - y^4/8; + assert (isAlways(taylor(f,[x,y],'order',6)== expected)) + assert (isAlways(taylor(f,[x,y],'expansionPoint', [0,0],'order',5) == expected)) ***** test - A = sym([1 2 3]); - B = sym([1 2 4]); - C = setdiff(A, B); - D = sym([3]); - assert (isequal (C, D)) + syms x y + f = sin (x^2 + y^2); + expected = sin(sym(1))+2*cos(sym(1))*(x-1)+(cos(sym(1))-2*sin(sym(1)))*(x-1)^2 + cos(sym(1))*y^2; + assert (isAlways(taylor(f,[x,y],'expansionPoint', [1,0],'order',3) == expected)) ***** test - % one nonsym - A = sym([1 2 3]); - B = [1 2 4]; - C = setdiff(A, B); - D = sym([3]); - assert (isequal (C, D)) + % key/value ordering doesn't matter + syms x y + f = exp(x+y); + g1 = taylor(f, 'expansionPoint',1, 'order', 3); + g2 = taylor(f, 'order', 3, 'expansionPoint',1); + assert (isAlways(g1== g2)) ***** test - % empty - A = sym([1 2 3]); - C = setdiff(A, A); - assert (isempty (C)) + syms x y + f = x^2 + y^2; + assert (isAlways(taylor(f,[x,y],[0,0],'order',0)== sym(0) )) + assert (isAlways(taylor(f,[x,y],[0,0],'order',1)== sym(0) )) + assert (isAlways(taylor(f,[x,y],[0,0],'order',2)== sym(0) )) + assert (isAlways(taylor(f,[x,y],[0,0],'order',3)== sym(x^2 + y^2))) + assert (isAlways(taylor(f,[x,y],[0,0],'order',4)== sym(x^2 + y^2))) ***** test - % empty input - A = sym([1 2]); - C = setdiff(A, []); - assert (isequal (C, A) || isequal (C, sym([2 1]))) + % expansion point + syms x a + f = x^2; + g = taylor(f,x,2); + assert (isequal (simplify(g), f)) + assert (isequal (g, 4*x+(x-2)^2-4)) + g = taylor(f,x,a); + assert (isequal (simplify(g), f)) ***** test - % scalar + % wrong order-1 series with nonzero expansion pt: + % upstream bug https://github.com/sympy/sympy/issues/9351 syms x - assert (isequal (setdiff([x 1], x), sym(1))) - assert (isempty (setdiff(x, x))) + g = x^2 + 2*x + 3; + h = taylor (g, x, 4, 'order', 1); + assert (isequal (h, 27)) ***** test - A = interval(sym(1), 3); - B = interval(sym(2), 5); - C = setdiff(A, B); - assert( isequal( C, interval(sym(1), 2, false, true))) -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@sym/angle.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/angle.m + syms x y z + g = x^2 + 2*y + 3*z; + h = taylor (g, [x,y,z], 'order', 4); + assert (isAlways(h == g)) ; ***** test - Z = [sqrt(sym(3)) + 3*sym(i), 3 + sqrt(sym(3))*sym(i); 1 + sym(i), sym(i)]; - Q = [sym(pi)/3 sym(pi)/6; sym(pi)/4 sym(pi)/2]; - assert( isequal( angle(Z), Q)); + syms x y z + g = sin(x*y*z); + h = taylor (g, [x,y,z], 'order', 4); + assert (isAlways(h == x*y*z)) ; +***** error + syms x y + taylor(0, [x, y], [1, 2, 3]); +18 tests, 18 passed, 0 known failure, 0 skipped +[inst/@sym/lu.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/lu.m ***** test - % roundtrip + % scalar + [l, u, p] = lu(sym(6)); + assert (isequal (l, sym(1))) + assert (isequal (u, sym(6))) + assert (isequal (p, sym(1))) syms x - A = angle (2+2i); - f = angle (x); - h = function_handle (f); - B = h (2+2i); - assert (A, B, -eps) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/round.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/round.m -***** test - d = 3/2; - x = sym('3/2'); - f1 = round(x); - f2 = round(d); - assert (isequal (f1, f2)) -***** xtest - % ideally rounding direction would match Octave - d = 5/2; - x = sym('5/2'); - f1 = round(x); - f2 = round(d); - assert (isequal (f1, f2)) -!!!!! known failure -assert (isequal (f1, f2)) failed + [l, u, p] = lu(x); + assert (isequal (l*u, p*x)) + [l, u] = lu(x); + assert (isequal (l*u, x)) ***** test - D = [1.1 4.6; -3.4 -8.9]; - A = [sym(11)/10 sym(46)/10; sym(-34)/10 sym(-89)/10]; - f1 = round(A); - f2 = round(D); - assert( isequal (f1, f2)) + % perm + A = sym(fliplr(2*eye(3))); + [L, U, P] = lu(A); + assert (isequal (L*U, P*A)) + [L, U, P] = lu(A, 'matrix'); + assert (isequal (L*U, P*A)) + [L, U, p] = lu(A, 'vector'); + assert (isequal (L*U, A(p,:))) + [L, U] = lu(A); + assert (isequal (L*U, A)) ***** test - d = sym(-11)/10; - c = -1; - assert (isequal (round (d), c)) + % p is col vectpr + A = sym([0 2; 3 4]); + [L, U, p] = lu(A, 'vector'); + assert(iscolumn(p)) ***** test - d = sym(-19)/10; - c = -2; - assert (isequal (round (d), c)) + % simple matrix + A = [1 2; 3 4]; + B = sym(A); + [L, U, P] = lu(B); + assert (isequal (L*U, P*B)) + assert (isequal (U(2,1), sym(0))) + % needs pivot + A = [0 2; 3 4]; + B = sym(A); + [L, U, P] = lu(B); + [Ld, Ud, Pd] = lu(A); + assert (isequal (L*U, P*A)) + assert (isequal (U(2,1), sym(0))) + % matches regular LU + assert ( max(max(double(L)-Ld)) <= 10*eps) + assert ( max(max(double(U)-Ud)) <= 10*eps) + assert ( isequal (P, Pd)) ***** test - d = 7j/2; - x = sym(7j)/2; - f1 = round (x); - f2 = round (d); - assert (isequal (f1, f2)) + % rectangular + A = sym([1 2; 3 4; 5 6]); + [L, U] = lu (A); + assert (isequal (L*U, A)) ***** test - d = 5/3 - 4j/7; - x = sym(5)/3 - sym(4j)/7; - f1 = round (x); - f2 = round (d); - assert (isequal (f1, f2)) -7 tests, 6 passed, 1 known failure, 0 skipped -[inst/@sym/max.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/max.m + % rectangular + A = sym([1 2 3; 4 5 6]); + [L, U] = lu (A); + assert (isequal (L*U, A)) ***** test - % simple - assert (isequal (max([sym(10) sym(11)]), sym(11))) + % rectangular, repeated row + A = sym([1 2 3; 2 4 6]); + [L, U] = lu (A); + assert (isequal (L*U, A)) ***** test - syms x y - assert (isequal (children (max (x, y)), [x y])) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/gradient.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/gradient.m + % rectangular, needs permutation + A = sym([0 0 0; 1 2 3]); + [L, U] = lu (A); + assert (isequal (L*U, A)) + assert (~isequal (tril (L), L)) + [L, U, P] = lu (A); + assert (isequal (L*U, P*A)) + assert (isequal (tril (L), L)) +8 tests, 8 passed, 0 known failure, 0 skipped +[inst/@sym/hessian.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/hessian.m +***** error hessian (sym(1), 2, 3) +***** error hessian ([sym(1) sym(2)]) ***** shared x,y,z syms x y z ***** test % 1D f = x^2; - assert (isequal (gradient(f), diff(f,x))) - assert (isequal (gradient(f,{x}), diff(f,x))) - assert (isequal (gradient(f,[x]), diff(f,x))) - assert (isequal (gradient(f,x), diff(f,x))) + assert (isequal (hessian(f), diff(f,x,x))) + assert (isequal (hessian(f,{x}), diff(f,x,x))) + assert (isequal (hessian(f,x), diff(f,x,x))) ***** test % const f = sym(1); g = sym(0); - assert (isequal (gradient(f), g)) - assert (isequal (gradient(f,x), g)) + assert (isequal (hessian(f), g)) + assert (isequal (hessian(f,x), g)) ***** test % double const f = 1; g = sym(0); - assert (isequal (gradient(f,x), g)) + assert (isequal (hessian(f,x), g)) ***** test - % 1D fcn in 2d/3d - f = sin(y); - assert (isequal (gradient(f), diff(f,y))) - assert (isequal (gradient(f, {x,y}), [sym(0); diff(f,y)])) - assert (isequal (gradient(f, [x y]), [sym(0); diff(f,y)])) - assert (isequal (size (gradient(f, {x,y})), [2 1])) - assert (isequal (gradient(f, {x,y,z}), [0; diff(f,y); 0])) - assert (isequal (gradient(f, [x y z]), [0; diff(f,y); 0])) - assert (isequal (size (gradient(f, {x,y,z})), [3 1])) + % linear + f = 42*x; + g = sym(0); + assert (isequal (hessian(f), g)) + assert (isequal (hessian(f,x), g)) ***** test - % grad is column vector - f = sin(y); - assert (isequal (size (gradient(f, {x,y})), [2 1])) - assert (isequal (size (gradient(f, {x,y,z})), [3 1])) - assert (isequal (size (gradient(f, [x y])), [2 1])) - assert (isequal (size (gradient(f, [x;y])), [2 1])) + % linear + f = 42*x - sym('a')*y; + g = [0 0; 0 0]; + assert (isequal (hessian(f, {x y}), g)) ***** test - % 2d fcn in 2d/3d - f = sin(exp(x)*y); - g2 = [diff(f,x); diff(f,y)]; - g3 = [diff(f,x); diff(f,y); diff(f,z)]; - assert (isequal (gradient(f), g2)) - assert (isequal (gradient(f, {x,y}), g2)) - assert (isequal (gradient(f, {x,y,z}), g3)) + % 2d + f = x*cos(y); + g = [0 -sin(y); -sin(y) -f]; + assert (isequal (hessian(f), g)) + assert (isequal (hessian(f, {x y}), g)) ***** test - % 2d fcn in 2d/3d - f = sin(exp(x)*y+sinh(z)); - g2 = [diff(f,x); diff(f,y)]; - g3 = [diff(f,x); diff(f,y); diff(f,z)]; - assert (isequal (gradient(f), g3)) - assert (isequal (gradient(f, {x,y}), g2)) - assert (isequal (gradient(f, {x,y,z}), g3)) -***** error gradient(sym('x'), 42, 42) -***** error gradient([sym('x') sym('x')]) + % 3d + f = x*cos(z); + Hexp = [0 0 -sin(z); sym(0) 0 0; -sin(z) 0 -f]; + H = hessian(f, {x y z}); + assert (isequal (H, Hexp)) 9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/erfinv.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/erfinv.m -***** error erfinv (sym(1), 2) -***** assert (isequaln (erfinv (sym(nan)), sym(nan))) -***** shared x, d - d = 1/2; - x = sym('1/2'); +[inst/@sym/cumsum.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cumsum.m +***** shared x, y + x = sym ('x'); + y = sym ('y'); +***** error cumsum (x, 1, 2) +***** assert (isequal (cumsum ([-x; -2*x; -3*x]), [-x; -3*x; -6*x])) +***** assert (isequal (cumsum ([x + 2i*y, 2*x + i*y]), [x + 2i*y, 3*x + 3i*y])) +***** assert (isequal (cumsum ([x, 2*x; 3*x, 4*x], 1), [1*x, 2*x; 4*x, 6*x] )) +***** assert (isequal (cumsum ([x, 2*x; 3*x, 4*x], 2), [1*x, 3*x; 3*x, 7*x] )) +***** test cumsum ([x, x], [2, 1]); # ensure behaves like builtin cumsum +***** test cumsum ([x, x], [1, -2]); # ensure behaves like builtin cumsum +***** error cumsum (x, []) +***** error cumsum (x, {1}) +***** error cumsum (x, struct('a', 1)) +***** error cumsum (x, x) +***** error cumsum (x, 0) +***** error cumsum (x, -1) +13 tests, 13 passed, 0 known failure, 0 skipped +[inst/@sym/euler.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/euler.m +***** error euler (sym(1), 2, 3) +***** assert (isequal (euler (sym(0)), sym(1))) ***** test - f1 = erfinv(x); - f2 = erfinv(d); - assert( abs(double(f1) - f2) < 1e-15 ) + m = sym([0 1 2; 8 10 888889]); + A = euler (m); + B = sym([1 0 -1; 1385 -50521 0]); + assert (isequal (A, B)) ***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = erfinv(A); - f2 = erfinv(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) + syms x + assert (isequal (euler(6, x), x^6 - 3*x^5 + 5*x^3 - 3*x)) +***** assert (isnan (euler (3, sym(nan)))) ***** test - % round trip - y = sym('y'); - A = erfinv (d); - f = erfinv (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/rhs.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/rhs.m + syms m x + em = euler (m, x); + A = subs(em, [m x], [2 sym(pi)]); + assert (isequal (A, sym(pi)^2 - sym(pi))) ***** test - syms x - f = x + 1 == 2*x; - assert (isequal (rhs(f), 2*x)) -***** error - syms x - rhs(x) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/logical.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/logical.m + % vectorized + syms x y + A = euler([1; 2], [x; y]); + B = [x - sym(1)/2; y^2 - y]; + assert (isequal (A, B)) ***** test - % basics, many others in isAlways.m - assert (logical(true)) - assert (~(logical(false))) + % round trip + syms m z + f = euler (m, z); + h = function_handle (f, 'vars', [m z]); + A = h (2, 2.2); + B = euler (2, 2.2); + assert (A, B) ***** test - % numbers to logic? - assert (logical(sym(1))) - assert (logical(sym(-1))) - assert (~logical(sym(0))) + % compare vpa to maple: Digits:=34; evalf(euler(13, exp(1)+Pi*I/13)); + A = vpa('1623.14184180556920918624604530515') + ... + vpa('4270.98066989140286451493108809574')*1i; + z = vpa (exp(1), 32) + vpa(pi, 32)/13*1i; + B = euler (13, z); + relerr = abs(double(abs((B - A)/A))); + assert (relerr < 20*eps); +***** xtest + % as above, high-prec result broken in 1.12: https://github.com/sympy/sympy/issues/24156 + A = vpa('1623.14184180556920918624604530515') + ... + vpa('4270.98066989140286451493108809574')*1i; + z = vpa (exp(1), 32) + vpa(pi, 32)/13*1i; + B = euler (13, z); + relerr = abs(double(abs((B - A)/A))); + assert (relerr < 2e-31); +!!!!! known failure +assert (relerr < 2e-31) failed +10 tests, 9 passed, 1 known failure, 0 skipped +[inst/@sym/rank.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/rank.m ***** test - % eqns, "structurally equivalent" - syms x - e = logical(x == x); - assert ( islogical (e)) - assert (e) - e = logical(x == 1); - assert ( islogical (e)) - assert (~e) + A = sym([1 2; 3 4]); + assert (rank(A) == 2); ***** test - % eqn could have solutions but are false in general - syms x - e = logical(x^2 == x); - assert ( islogical (e)) - assert (~e) - e = logical(2*x == x); - assert ( islogical (e)) - assert (~e) + A = sym([1 2 3; 3 4 5]); + assert (rank(A) == 2); ***** test - % FIXME: (not sure yet) T/F matrices should stay sym until logical() - a = sym(1); - e = a == a; - assert (isa (e, 'sym')) - assert (islogical (logical (e))) - e = [a == a a == 0 a == a]; - assert (isa (e, 'sym')) - assert (islogical (logical (e))) + A = sym([1 2; 1 2]); + assert (rank(A) == 1); ***** test - % sym vectors of T/F to logical - a = sym(1); - e = [a == a a == 0 a == a]; - w = logical(e); - assert (islogical (w)) - assert (isequal (w, [true false true])) - e = e'; - w = logical(e); - assert (islogical (w)) - assert (isequal (w, [true; false; true])) + A = sym([1 2; 3 4]); + assert (rank(A) == 2); +***** assert (rank(sym(1)) == 1); +***** assert (rank(sym(0)) == 0); +***** assert (rank(sym('x', 'positive')) == 1); +7 tests, 7 passed, 0 known failure, 0 skipped +[inst/@sym/mtimes.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/mtimes.m ***** test - % sym matrix of T/F to logical - a = sym([1 2 3; 4 5 6]); - b = sym([1 2 0; 4 0 6]); - e = a == b; - w = logical(e); - assert (islogical (w)) - assert (isequal (w, [true true false; true false true])) -***** error + % scalar syms x - logical(x); -***** error - logical(sym(nan)) -***** test - % but oo and zoo are non-zero so we call those true - % (SMT errors on these) FIXME - syms oo zoo - assert (logical (oo)) - % assert (logical (zoo)) + assert (isa (x*2, 'sym')) + assert (isequal (2*sym(3), sym(6))) + assert (isequal (sym(2)*3, sym(6))) ***** test - % older Octave (< 4.2) didn't automatically do "if (logical(obj))" - e = sym(true); - if (e) - assert(true); - else - assert(false); - end + % matrix-scalar + D = [0 1; 2 3]; + A = sym(D); + assert (isa (2*A, 'sym')) + assert (isequal ( 2*A , 2*D )) + assert (isequal ( A*2 , 2*D )) ***** test - % more of above - e2 = sym(1) == sym(1); - if (e2) - assert(true); - else - assert(false); - end - e3 = sym([1 2]) == sym([1 1]); - if (e3(1)) - assert(true); - else - assert(false); - end -12 tests, 12 passed, 0 known failure, 0 skipped -[inst/@sym/asec.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/asec.m -***** error asec (sym(1), 2) -***** assert (isequaln (asec (sym(nan)), sym(nan))) -***** shared x, d - d = 2; - x = sym('2'); + % matrix-matrix + D = [0 1; 2 3]; + A = sym(D); + assert (isa (A*A, 'sym')) + assert (isequal ( A*A , D*D )) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/collect.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/collect.m +***** test syms x y z + f = [x*y + x - 3 + 2*x^2 - z*x^3 + x^3]; + assert (logical (collect (f,x) == ((x^3)*(1 - z) + 2*(x^2) + x*(y + 1) - 3))) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@sym/polylog.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/polylog.m +***** assert (isequal (polylog (sym('s'), 0), sym(0))) +***** assert (isequal (double (polylog (1, sym(-1))), -log(2))) +***** assert (isequal (double (polylog (0, sym(2))), -2)) +***** assert (isequal (double (polylog (-1, sym(2))), 2)) +***** assert (isequal (double (polylog (-2, sym(3))), -1.5)) +***** assert (isequal (double (polylog (-3, sym(2))), 26)) +***** assert (isequal (double (polylog (-4, sym(3))), -15)) +***** assert (isequal (double (polylog (1, sym(1)/2)), log(2))) ***** test - f1 = asec(x); - f2 = asec(d); - assert( abs(double(f1) - f2) < 1e-15 ) + % round trip + syms s z + f = polylog (s, z); + h = function_handle (f, 'vars', [s z]); + A = h (1.1, 2.2); + B = polylog (1.1, 2.2); + assert (A, B) +9 tests, 9 passed, 0 known failure, 0 skipped +[inst/@sym/le.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/le.m ***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = asec(A); - f2 = asec(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) + % simple + x = sym(1); y = sym(1); e = x <= y; + assert (logical (e)) + x = sym(1); y = sym(2); e = x <= y; + assert (logical (e)) ***** test - % round trip - y = sym('y'); - A = asec (d); - f = asec (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/gamma.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/gamma.m -***** error gamma (sym(1), 2) -***** assert (isequaln (gamma (sym(nan)), sym(nan))) + % array -- array + syms x + a = sym([1 3 3 2*x]); + b = sym([2 x 3 10]); + e = a <= b; + assert (isa (e, 'sym')) + assert (logical (e(1))) + assert (isa (e(2), 'sym')) + assert (isequal (e(2), 3 <= x)) + assert (logical (e(3))) + assert (isa (e(4), 'sym')) + assert (isequal (e(4), 2*x <= 10)) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/cos.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cos.m +***** error cos (sym(1), 2) +***** assert (isequaln (cos (sym(nan)), sym(nan))) ***** shared x, d d = 1; x = sym('1'); ***** test - f1 = gamma(x); - f2 = gamma(d); + f1 = cos(x); + f2 = cos(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = gamma(A); - f2 = gamma(D); + f1 = cos(A); + f2 = cos(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = gamma (d); - f = gamma (y); + A = cos (d); + f = cos (y); h = function_handle (f); B = h (d); assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/jacobian.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/jacobian.m -***** error jacobian (sym(1), 2, 3) -***** error jacobian ([sym(1) 2; sym(3) 4]) -***** shared x,y,z - syms x y z -***** test - % 1D - f = x^2; - assert (isequal (jacobian(f), diff(f,x))) - assert (isequal (jacobian(f,{x}), diff(f,x))) - assert (isequal (jacobian(f,x), diff(f,x))) -***** test - % const - f = sym(1); - g = sym(0); - assert (isequal (jacobian(f), g)) - assert (isequal (jacobian(f,x), g)) -***** test - % double const - f = 1; - g = sym(0); - assert (isequal (jacobian(f,x), g)) -***** test - % diag - f = [x y^2]; - g = [sym(1) 0; 0 2*y]; - assert (isequal (jacobian(f), g)) - assert (isequal (jacobian(f, [x y]), g)) - assert (isequal (jacobian(f, {x y}), g)) -***** test - % anti-diag - f = [y^2 x]; - g = [0 2*y; sym(1) 0]; - assert (isequal (jacobian(f), g)) - assert (isequal (jacobian(f, {x y}), g)) -***** test - % shape - f = [x y^2]; - assert (isequal (size(jacobian(f, {x y z})), [2 3])) - assert (isequal (size(jacobian(f, [x y z])), [2 3])) - assert (isequal (size(jacobian(f, [x; y; z])), [2 3])) - assert (isequal (size(jacobian(f.', {x y z})), [2 3])) -***** test - % scalar f - f = x*y; - assert (isequal (size(jacobian(f, {x y})), [1 2])) - g = gradient(f, {x y}); - assert (isequal (jacobian(f, {x y}), g.')) -***** test - % vect f wrt 1 var - f = [x x^2]; - assert (isequal (size(jacobian(f, x)), [2 1])) - f = f.'; % same shape output - assert (isequal (size(jacobian(f, x)), [2 1])) -10 tests, 10 passed, 0 known failure, 0 skipped -[inst/@sym/ztrans.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ztrans.m -***** test - % basic Z-transform table checks - % X1, ..., X4 must have inner radius of convergence 1 - syms n z - % trick to extract the closed form formula using the fact that inner roc = 1 - closed_form = @(X) subs (X, abs (1 / z), 1 / sym (2)); - % check if ztrans(f) == X - check_ztrans = @(f, X) logical (simplify (closed_form (ztrans (f)) == X)); - f1 = sym (1); - X1 = 1 / (1 - 1 / z); - assert (check_ztrans (f1, X1)); - f2 = n; - X2 = (1 / z) / (1 - 1 / z)^2; - assert (check_ztrans (f2, X2)); - f3 = n^2; - X3 = (1 / z) * (1 + 1 / z) / (1 - 1 / z)^3; - assert (check_ztrans (f3, X3)); - f4 = n^3; - X4 = (1 / z) * (1 + 4 / z + 1 / z^2) / (1 - 1 / z)^4; - assert (check_ztrans (f4, X4)); - % basic matrix checks - A1 = ztrans ([f1 f2; f3 f4]); - B1 = [ztrans(f1) ztrans(f2); ztrans(f3) ztrans(f4)]; - assert (isequal (A1, B1)); - A2 = ztrans ([f1 f2; f3 f4], z); - B2 = [ztrans(f1, z) ztrans(f2, z); ztrans(f3, z) ztrans(f4, z)]; - assert (isequal (A2, B2)); - A3 = ztrans ([f1 f2; f3 f4], n, z); - B3 = [ztrans(f1, n, z) ztrans(f2, n, z); ztrans(f3, n, z) ztrans(f4, n, z)]; - assert (isequal (A3, B3)); -***** test - % additional Z-transform table checks - % X1, ..., X4 must have inner radius of convergence a - syms n nonnegative integer - syms m positive integer - syms a - syms z - % trick to extract the closed form formula using the fact that inner roc = a - closed_form = @(X) subs (X, abs (a / z), 1 / sym (2)); - % check if ztrans(f) == X - check_ztrans = @(f, X) logical (simplify (closed_form (ztrans (f)) == X)); - f1 = a^n; - X1 = 1 / (1 - a / z); - assert (check_ztrans (f1, X1)); - f2 = n * a^n; - X2 = (a / z) / (1 - a / z)^2; - assert (check_ztrans (f2, X2)); - f3 = n^2 * a^n; - X3 = (a / z) * (1 + a / z) / (1 - a / z)^3; - assert (check_ztrans (f3, X3)); - f4 = nchoosek(n + m - 1, m - 1) * a^n; - X4 = 1 / (1 - a / z)^m; - assert (check_ztrans (f4, X4)); - % additional matrix checks - A1 = ztrans (f1, [n m; m n], [z a; a z]); - B1 = [ztrans(f1, n, z) ztrans(f1, m, a); ztrans(f1, m, a) ztrans(f1, n, z)]; - assert (isequal (A1, B1)); - A2 = ztrans (f1, m, [z a; a z]); - B2 = [ztrans(f1, m, z) ztrans(f1, m, a); ztrans(f1, m, a) ztrans(f1, m, z)]; - assert (isequal (A2, B2)); - A3 = ztrans (f1, [n m; m n], a); - B3 = [ztrans(f1, n, a) ztrans(f1, m, a); ztrans(f1, m, a) ztrans(f1, n, a)]; - assert (isequal (A3, B3)); +[inst/@sym/private_disp_name.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/private_disp_name.m ***** test - % Kronecker delta checks - syms n n0 nonnegative integer - syms z - assert (isequal (ztrans (kroneckerDelta (n)), 1)); - assert (isequal (ztrans (kroneckerDelta (n - n0)), 1 / z^n0)); + syms x + s = private_disp_name(x, 'x'); + assert (strcmp (s, 'x')) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@sym/ismember.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ismember.m +***** assert (ismember (2, interval(sym(0),2))) +***** assert (~ismember (3, interval(sym(0),2))) ***** test - % basic var selection checks - syms n m z w - assert (isequal (ztrans (1 / factorial (n)), exp (1 / z))); - assert (isequal (ztrans (1 / factorial (z)), exp (1 / w))); - assert (isequal (ztrans (1 / factorial (m), w), exp (1 / w))); - assert (isequal (ztrans (1 / factorial (m), m, w), exp (1 / w))); + % something in a matrix + syms x + A = [1 x; sym(pi) 4]; + assert (ismember (sym(pi), A)) + assert (ismember (x, A)) + assert (~ismember (2, A)) ***** test - % additional var selection checks - syms n m z - f = kroneckerDelta(m) / factorial (n); - assert (isequal (ztrans (f, z), exp (1 / z) * kroneckerDelta (m))); - assert (isequal (ztrans (f, n, z), exp (1 / z) * kroneckerDelta (m))); - assert (isequal (ztrans (f, m, z), 1 / factorial (n))); + % set + syms x + S = finiteset(2, sym(pi), x); + assert (ismember (x, S)) ***** test - % if no t, use symvar: take x before a - syms a x z - assert (isequal (ztrans (a / factorial (x)), a * exp (1 / z))); -***** error ztrans (sym ('n')^sym ('n', 'nonnegative', 'integer')) -7 tests, 7 passed, 0 known failure, 0 skipped -[inst/@sym/ccode.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ccode.m -***** shared x,y,z - syms x y z + % set with positive symbol + syms p positive + S = finiteset(2, sym(pi), p); + assert (~ismember (-1, S)) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/minus.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/minus.m ***** test - % basic test - f = x*sin(y) + abs(z); - source = ccode(f); - expected = 'x*sin(y) + fabs(z)'; - assert(strcmp(source, expected)) + % scalar + syms x + assert (isa (x-1, 'sym')) + assert (isa (x-x, 'sym')) + assert (isequal (x-x, sym(0))) ***** test - % output test - f = x*sin(y) + abs(z); - [C, H] = ccode(f, 'file', '', 'show_header', false); - expected_c_code = sprintf('#include \"file.h\"\n#include \n\ndouble myfun(double x, double y, double z) {\n\n double myfun_result;\n myfun_result = x*sin(y) + fabs(z);\n return myfun_result;\n\n}\n'); - expected_h_code = sprintf('\n#ifndef PROJECT__FILE__H\n#define PROJECT__FILE__H\n\ndouble myfun(double x, double y, double z);\n\n#endif\n\n'); - assert(strcmp(C.name, 'file.c')) - assert(strcmp(H.name, 'file.h')) - hwin = strrep(expected_h_code, sprintf('\n'), sprintf('\r\n')); - assert (strcmp (H.code, expected_h_code) || strcmp (H.code, hwin)) - s1 = expected_c_code; - s2 = strrep(expected_c_code, sprintf('\n'), sprintf('\r\n')); - assert (strcmp (C.code, s1) || strcmp (C.code, s2)) + % matrices + D = [0 1; 2 3]; + A = sym(D); + DZ = D - D; + assert (isequal ( A - D , DZ )) + assert (isequal ( A - A , DZ )) + assert (isequal ( D - A , DZ )) + assert (isequal ( A - 2 , D - 2 )) + assert (isequal ( 4 - A , 4 - D )) 2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/bessely.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/bessely.m -***** test - X = [1 2 3; 4 5 6]; - ns = [sym(0) 1 -2; sym(1)/2 -sym(3)/2 pi]; - n = double(ns); - A = double(bessely(ns, X)); - B = bessely(n, X); - assert (all (all (abs (A - B) < 50*eps*abs(A)))) +[inst/@sym/rewrite.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/rewrite.m ***** test - % roundtrip syms x - A = bessely(2, 10); - q = bessely(2, x); - h = function_handle(q); - B = h(10); - assert (abs (A - B) <= eps*abs(A)) -***** error bessely(sym('x')) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/find.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/find.m -***** error find (sym (1), 2, 3, 4) -***** error [x, y, z, w] = find (sym (1)) -***** test - syms x y positive - assert (isequal (find ([0 x 0 y]), [2 4])) - assert (isequal (find ([0 x 0 y], 1), 2)) - assert (isequal (find ([0 x 0 y], 1, 'first'), 2)) - assert (isequal (find ([0 x 0 y], 1, 'last'), 4)) - assert (isequal (find ([0 x 0 y], 2, 'last'), [2 4])) -***** test - % its enough that it could be non-zero, does not have to be - syms x y - assert (isequal (find ([0 x+y]), 2)) -***** test - % false should not be found - syms x y - assert (isequal (find ([x==x x==y]), 1)) - assert (isequal (find ([x==y]), [])) -***** test - % and/or should be treated as boolean - syms x y - assert (isequal (find ([or(x==y, x==2*y) x==y x==x]), 3)) -***** test - % None - none = pycall_sympy__ ('return None'); - assert (isequal (find ([sym(0) none sym(1)]), 3)) - syms x y - assert (isequal (find ([x==y none x==x]), 3)) -***** test - % two output - syms x y - A = [x 0 0; x+y 5 0]; - [i, j] = find (A); - assert (isequal (i, [1; 2; 2])) - assert (isequal (j, [1; 1; 2])) -***** test - % three output - syms x y - A = [x 0 0; x+y 5 0]; - [i, j, v] = find (A); - assert (isequal (i, [1; 2; 2])) - assert (isequal (j, [1; 1; 2])) - assert (isequal (v, [x; x+y; sym(5)])) -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/collect.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/collect.m -***** test syms x y z - f = [x*y + x - 3 + 2*x^2 - z*x^3 + x^3]; - assert (logical (collect (f,x) == ((x^3)*(1 - z) + 2*(x^2) + x*(y + 1) - 3))) -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@sym/fourier.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/fourier.m + assert (isequal (rewrite(x, 'exp'), x)) ***** test - % matlab SMT compatibility for arguments - syms r x u w v - Pi=sym('pi'); - assert(logical( fourier(exp(-x^2)) == sqrt(Pi)/exp(w^2/4) )) - assert(logical( fourier(exp(-w^2)) == sqrt(Pi)/exp(v^2/4) )) - assert(logical( fourier(exp(-r^2),u) == sqrt(Pi)/exp(u^2/4) )) - assert(logical( fourier(exp(-r^2),r,u) == sqrt(Pi)/exp(u^2/4) )) + % empty + e = sym([]); + assert (isequal (rewrite(e, 'sin'), e)) ***** test - % basic tests - syms x w - assert(logical( fourier(exp(-abs(x))) == 2/(w^2 + 1) )) - assert(logical( fourier(x*exp(-abs(x))) == -(w*4*1i)/(w^4 + 2*w^2 + 1) )) + syms x + A = [exp(x) exp(2*x)]; + B = [sinh(x) + cosh(x) sinh(2*x) + cosh(2*x)]; + assert (isequal (rewrite(A, 'sin'), B)) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/fresnelc.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/fresnelc.m +***** error fresnelc (sym(1), 2) ***** test - % Dirac delta tests - syms x w - Pi=sym('pi'); - assert(logical( fourier(dirac(x-2)) == exp(-2*1i*w) )) - assert (logical( fourier(sym(2), x, w) == 4*Pi*dirac(w) )) + a = fresnelc(sym(0)); + assert (isequal (a, sym(0))) ***** test - % advanced test - syms x w c d - Pi=sym('pi'); - F=Pi*(dirac(w-c)+dirac(w+c))+2*Pi*1i*(dirac(w+3*d)-dirac(w-3*d))+2/(w^2+1); - assert(logical( fourier(cos(c*x)+2*sin(3*d*x)+exp(-abs(x))) == expand(F) )) -***** xtest - % Differential operator to algebraic - % SymPy cannot evaluate? (Issue #170) - syms x w f(x) - assert(logical( fourier(diff(f(x),x),x,w) == -1i*w*fourier(f(x),x,w) )) -!!!!! known failure -assert (logical (fourier (diff (f (x), x), x, w) == -1i * w * fourier (f (x), x, w))) failed -5 tests, 4 passed, 1 known failure, 0 skipped -[inst/@sym/ipermute.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ipermute.m -***** error permute (sym(1)) -***** error permute (sym(1), 2, 3) + b = fresnelc(sym('oo')); + assert (isequal (b, sym(1)/2)) ***** test + % values in a matrix syms x - A = [1 x]; - perm = [2 1]; - B = permute(A, perm); - C = ipermute(B, perm); - assert (isequal(C, A)) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/harmonic.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/harmonic.m -***** error harmonic (sym(1), 2) -***** xtest - assert (isequaln (harmonic (sym(nan)), sym(nan))) -!!!!! known failure -assert (isequaln (harmonic (sym (nan)), sym (nan))) failed -***** assert (isequal (harmonic (sym(0)), sym(0))) -***** assert (isinf (harmonic (sym(inf)))) -***** assert (isequal (harmonic (sym([9 10])), [sym(7129)/2520 sym(7381)/2520])) + a = fresnelc([sym(0) sym('oo') x 1]); + b = [sym(0) sym(1)/2 fresnelc(x) fresnelc(sym(1))]; + assert (isequal (a, b)) ***** test % round trip - y = sym('y'); - A = harmonic (7); - f = harmonic (y); + syms x + f = fresnelc (x); h = function_handle (f); - B = h (7); - assert (A, B, -eps) -6 tests, 5 passed, 1 known failure, 0 skipped -[inst/@sym/cumprod.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cumprod.m -***** shared x, y - x = sym ('x'); - y = sym ('y'); -***** error cumprod (x, 1, 2) -***** assert (isequal (cumprod ([-x; -2*x; -3*x]), [-x; 2*x^2; -6*x^3])) -***** assert (isequal (expand (cumprod ([x + i, x - i])), [x + i, x^2 + 1])) -***** assert (isequal (cumprod ([1, x; y, 2], 1), [1, x; y, 2*x] )) -***** assert (isequal (cumprod ([1, x; y, 2], 2), [1, x; y, 2*y] )) -***** test cumprod ([x, x], [2, 1]); # ensure behaves like builtin cumprod -***** test cumprod ([x, x], [1, -2]); # ensure behaves like builtin cumprod -***** error cumprod (x, []) -***** error cumprod (x, {1}) -***** error cumprod (x, struct('a', 1)) -***** error cumprod (x, x) -***** error cumprod (x, 0) -***** error cumprod (x, -1) -13 tests, 13 passed, 0 known failure, 0 skipped -[inst/@sym/null.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/null.m + A = h (1.1); + B = fresnelc (1.1); + assert (A, B) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/cosd.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cosd.m +***** error cosd (sym(1), 2) +***** assert (isequaln (cosd (sym(nan)), sym(nan))) ***** test - A = sym([1 2; 3 4]); - assert (isempty (null (A))) -***** assert (isempty (null (sym(4)))) + f1 = cosd (sym(1)); + f2 = cosd (1); + assert (double (f1), f2, -eps) ***** test - A = sym([1 2 3; 3 4 5]); - assert (isequal (null(A), sym([1;-2;1]))) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/coshint.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/coshint.m -***** error coshint (sym(1), 2) + D = [10 30; 110 -45]; + A = sym(D); + f1 = cosd (A); + f2 = cosd (D); + assert (double (f1), f2, -4*eps) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/factorial.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/factorial.m +***** error factorial (sym(1), 2) ***** xtest - assert (isequaln (coshint (sym(nan)), sym(nan))) + assert (isequaln (factorial (sym(nan)), sym(nan))) !!!!! known failure -assert (isequaln (coshint (sym (nan)), sym (nan))) failed +assert (isequaln (factorial (sym (nan)), sym (nan))) failed ***** shared x, d d = 1; x = sym('1'); ***** test - f1 = coshint(x); - f2 = 0.8378669409802082408947; + f1 = factorial(x); + f2 = factorial(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = coshint(A); - f2 = 0.8378669409802082408947; - f2 = [f2 f2; f2 f2]; + f1 = factorial(A); + f2 = factorial(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = coshint (d); - f = coshint (y); + A = factorial (d); + f = factorial (y); h = function_handle (f); B = h (d); assert (A, B, -eps) 5 tests, 4 passed, 1 known failure, 0 skipped -[inst/@sym/factor.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/factor.m +[inst/@sym/jordan.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/jordan.m ***** test - % n = 152862; - % [p,m] = factor(n); % only works on Octave, no Matlab as of 2014a - n = 330; % so we use an output without repeated factors - p = factor(n); m = ones(size(p)); - [ps,ms] = factor(sym(n)); - assert (isequal (p, ps)) - assert (isequal (m, ms)) + % basic + A = sym ([2 1 0 0; 0 2 1 0; 0 0 3 0; 0 1 -1 3]); + [V, J] = jordan (A); + assert (isequal (inv (V) * A * V, J)); + assert (isequal (J, sym ([2 1 0 0; 0 2 0 0; 0 0 3 0; 0 0 0 3]))) + % the first 2 generalized eigenvectors form a cycle + assert (isequal ((A - J(1, 1) * eye (4)) * V(:, 1), zeros (4, 1))); + assert (isequal ((A - J(2, 2) * eye (4)) * V(:, 2), V(:, 1))); + % the last 2 generalized eigenvectors are eigenvectors + assert (isequal ((A - J(3, 3) * eye (4)) * V(:, 3), zeros (4, 1))); + assert (isequal ((A - J(4, 4) * eye (4)) * V(:, 4), zeros (4, 1))); ***** test - n = sym(2)^4*13; - [p,m] = factor(n); - assert (isequal (p, [2 13])) - assert (isequal (m, [4 1])) -***** test syms x - assert( logical (factor(x^2 + 6*x + 5) == (x+5)*(x+1))) + % scalars + assert (isequal (jordan (sym (-10)), sym (-10))); + assert (isequal (jordan (sym ('x')), sym ('x'))); ***** test - syms x - f = [ x^4/2 + 5*x^3/12 - x^2/3 x^2 - 1 10]; - g = [ x^2*(2*x - 1)*(3*x + 4)/12 (x+1)*(x-1) 10]; - assert (isequal (factor(f), g)) + % diagonal matrices + A = diag (sym ([6 6 7])); + [V1, D] = eig (A); + [V2, J] = jordan (A); + assert (isequal (V1, V2)); + assert (isequal (D, J)); ***** test - % "fragile form" works - A = factor(sym(124)); - B = strtrim(disp(A, 'flat')); - assert (strcmp (B, '2**2*31**1')) -***** error [p, m] = factor(sym('x')); -***** error [p, m] = factor(sym(42), sym('x')); + % matrices of unknown entries + A = [sym('a') sym('b'); sym('c') sym('d')]; + [V, D] = eig (A); + J = jordan (A); + assert (isequal (simplify (D), simplify (J))); ***** test - % if polynomial happens to be a constant, don't attempt integer - % factorization if a variable is specified - f = sym(42); - q = factor(f, sym('x')); - assert (isequal (f, q)); -8 tests, 8 passed, 0 known failure, 0 skipped -[inst/@sym/log.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/log.m -***** error log (sym(1), 2) -***** assert (isequaln (log (sym(nan)), sym(nan))) + % matrices of mixed entries + A = [sym('x')+9 sym('y'); sym(0) 6]; + [V, D] = eig (A); + J = jordan (A); + assert (isequal (simplify (D), simplify (J))); +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/gamma.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/gamma.m +***** error gamma (sym(1), 2) +***** assert (isequaln (gamma (sym(nan)), sym(nan))) ***** shared x, d d = 1; x = sym('1'); ***** test - f1 = log(x); - f2 = log(d); + f1 = gamma(x); + f2 = gamma(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = log(A); - f2 = log(D); + f1 = gamma(A); + f2 = gamma(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = log (d); - f = log (y); + A = gamma (d); + f = gamma (y); h = function_handle (f); B = h (d); assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/nchoosek.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/nchoosek.m -***** assert (isequal (nchoosek(sym(5), sym(2)), sym(10))) -***** assert (isequal (nchoosek(sym(5), 2), sym(10))) -***** assert (isequal (nchoosek(5, sym(2)), sym(10))) -***** assert (isequal (nchoosek(sym(10), 0), 1)) -***** assert (isequal (nchoosek(sym(10), -1), 0)) -***** test - n = sym('n', 'nonnegative', 'integer'); - assert (isequal (nchoosek (n, n), sym(1))) -***** test - n = sym('n', 'integer'); - q = nchoosek(n, 2); - w = subs(q, n, 5); - assert (isequal (w, 10)) -***** test - n = sym('n', 'integer'); - k = sym('k', 'integer'); - q = nchoosek(n, k); - w = subs(q, {n k}, {5 2}); - assert (isequal (w, 10)) -***** test - % negative input - assert (isequal (nchoosek (sym(-2), sym(5)), sym(-6))) -***** test - % complex input - n = sym(1 + 3i); - k = sym(5); - A = nchoosek (n, k); - B = gamma (n + 1) / (gamma (k + 1) * gamma (n - k + 1)); - assert (double (A), double (B), -2*eps) -***** test - % complex input - n = sym(-2 + 3i); - k = sym(1 + i); - A = nchoosek (n, k); - B = gamma (n + 1) / (gamma (k + 1) * gamma (n - k + 1)); - assert (double (A), double (B), -2*eps) -11 tests, 11 passed, 0 known failure, 0 skipped -[inst/@sym/rows.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/rows.m +[inst/@sym/uminus.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/uminus.m ***** test - a = sym([1 2 3]); - assert (rows(a) == 1) + % scalar + syms x + assert (isa (-x, 'sym')) + assert (isequal (-(-x), x)) ***** test - a = sym([1 2 3; 4 5 6]); - assert (rows(a) == 2) + % matrix + D = [0 1; 2 3]; + A = sym(D); + assert( isequal( -A, -D )) 2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/rref.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/rref.m -***** test - A = sym([1 2; 3 4]); - [r, k] = rref(A); - assert (isequal (r, eye(2))) - assert (isequal (k, [1 2])) -***** assert (isequal (rref(sym([2 1])), [1 sym(1)/2])) -***** assert (isequal (rref(sym([1 2; 2 4])), [1 2; 0 0])) -***** assert (isequal (rref(sym([0 0; 2 4])), [1 2; 0 0])) -***** test - A = sym([1 2 3; 2 3 4]); - [r, k] = rref(A); - assert (isequal (r, [1 0 -1; 0 1 2])) - assert (isequal (k, [1 2])); -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/gammaln.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/gammaln.m -***** assert (isequal (gammaln (sym (3)), log (sym (2)))) -***** assert (isequal (gammaln (sym (10)), log (gamma (sym (10))))) -***** test - % compare to Maple: evalf(lnGAMMA(Pi)); - maple = vpa ('0.827694592323437101529578558452359951153502', 40); - us = vpa (gammaln (sym(pi)), 40); - assert (abs(double(maple-us)) < 1e-39) -***** test - % compare to Maple: evalf(lnGAMMA(3+2*I)); - maple = vpa ('-0.0316390593739611898037677296008797172022603', 40) + ... - vpa ('2.02219319750132712401643376238334982100512j', 40); - us = vpa (gammaln (sym(3) + 2i), 40); - assert (abs(double(maple-us)) < 1e-39) -***** test - % compare to Maple: evalf(lnGAMMA(-1.5)); - % notably, @double/gammaln has zero imag part - maple = vpa ('0.8600470153764810145109326816703567873271571', 40) - ... - vpa ('6.2831853071795864769252867665590057683943388j', 40); - us = vpa (gammaln (-sym(3)/2), 40); - assert (abs(double(maple-us)) < 1e-39) -***** assert (gammaln (pi), double (gammaln (sym (pi))), -3*eps) -***** assert (gammaln (100), double (gammaln (sym (100))), -3*eps) -***** assert (gammaln (1e-3), double (gammaln (1/sym (1e3))), -100*eps) +[inst/@sym/chebyshevT.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/chebyshevT.m +***** error chebyshevT (sym(1)) +***** error chebyshevT (sym(1), 2, 3) +***** assert (isequaln (chebyshevT (2, sym(nan)), sym(nan))) +***** shared x + syms x +***** assert(isequal(chebyshevT(0, x), sym(1))) +***** assert(isequal(chebyshevT(1, x), x)) +***** assert(isequal(chebyshevT(2, x), 2*x*x - 1)) +***** assert(isequal(chebyshevT([0 1 2], x), [sym(1) x (2*x*x-1)])) ***** test % round trip - syms x - f = gammaln (x); - h = function_handle (f); - A = h (1.1); - B = gammaln (1.1); + syms n z + f = chebyshevT (n, z); + h = function_handle (f, 'vars', [n z]); + A = h (1.1, 2.2); + B = chebyshevT (1.1, 2.2); assert (A, B) -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/invhilb.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/invhilb.m -***** test - A = invhilb(sym(3)); - B = sym([9 -36 30;-36 192 -180;30 -180 180]); - assert( isequal( A, B)) -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@sym/eq.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/eq.m -***** test - % simple tests with scalar numbers - assert (logical (sym(1) == sym(1))) - assert (logical (sym(1) == 1)) - assert (~logical (sym(1) == 0)) - assert (isequal (sym(1) == sym(1), sym(true))) - assert (isequal (sym(1) == 1, sym(true))) - assert (isequal (sym(1) == 0, sym(false))) -***** test - % Type of the output is sym or logical? - % FIXME: in current version, they are sym - e = sym(1) == sym(1); - %assert (islogical (e)) - assert (isa (e, 'sym')) +8 tests, 8 passed, 0 known failure, 0 skipped +[inst/@sym/mod.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/mod.m +***** error mod (sym(1), 2, 3 ,4) +***** assert (isequal (mod (sym(5), 4), sym(1))) +***** assert (isequal (mod ([sym(5) 8], 4), [1 0] )) +***** assert (isequal (mod (sym(5), [2 3]), [1 2] )) +***** assert (isequal (mod ([sym(5) sym(6)], [2 3]), [1 0] )) ***** test - % things involving a variable are usually not bool but sym. - % (SMT behaviour says always, FIXME: currently we differ.) syms x - e = x == 0; - assert (~islogical (e)) - assert (isa (e, 'sym')) + assert (isequal ( mod (5*x, 3), 2*x )) ***** test - % ... except of course via cancellation syms x - e = x - x == 0; - assert (logical (e)) - assert (isequal (e, sym(true))) + a = [7*x^2 + 3*x + 3 3*x; 13*x^4 6*x]; + assert (isequal ( mod (a,3), [x^2 0; x^4 0] )) ***** test - % array == array - a = sym([1 2; 3 4]); - y = a == a; - assert (isequal( size(y), [2 2])) - assert (isequal (y, sym([true true; true true]))) - assert (all(all(y))) - y = a == 1; - assert (isequal( size(y), [2 2])) - assert (isequal (y, sym([true false; false false]))) - assert (any(any(y))) - y = a == 42; - assert (isequal( size(y), [2 2])) - assert (isequal (y, sym([false false; false false]))) + % vector of polys with mix of vars: symvar on each + syms x y + a = [6*x 7*y]; + b = mod(a, 4); + c = [2*x 3*y]; + assert (isequal (b, c)) ***** test - % more array == array - D = [0 1; 2 3]; - A = [sym(0) 1; sym(2) 3]; - DZ = D - D; - assert (isequal (logical(A == A), [true true; true true])) - assert (isequal (logical(A == D), [true true; true true])) - assert (isequal (logical(A - D == DZ), [true true; true true])) - assert (all (all ( A == A ))) - assert (all (all ( A == D ))) - assert (all (all ( A - D == DZ ))) + % coeff has variable + syms x + n = sym('n', 'integer'); + p = (3*n + 2)*x; + q = mod(p, 3); + assert (isequal (q, 2*x)) ***** test - % logical output, right shape, etc - t = true; f = false; - a = sym([0 1 2; 3 4 5]); - b = sym([0 1 1; 3 5 5]); - e = a == b; - eexp = sym(logical([1 1 0; 1 0 1])); - assert (isequal (e, eexp)) - a = sym([0 1 2]); - b = sym([0 1 1]); - e = a == b; - eexp = sym(logical([1 1 0])); - assert (isequal (e, eexp)) - e = a' == b'; - eexp = eexp.'; % is/was bug here with ' - assert (isequal (e, eexp)) + % coeff has variable + syms x a + p = a*x; + q = mod(p, 3); + q = children(q); + q = q(2); % order might be fragile! + w = subs(q, a, 5); + assert (isequal (w, 2)) ***** test - % empty matrices compare to correct empty size - a = zeros (sym(3), 0); - assert (size (a == a), [3, 0]) - a = zeros (sym(0), 2); - assert (size (a == a), [0, 2]) -8 tests, 8 passed, 0 known failure, 0 skipped -[inst/@sym/union.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/union.m + % different modulo + syms x y + q = mod([5*x + 10 5*y + 10], [2 3]); + assert (isequal (q, [x 2*y + 1])) +11 tests, 11 passed, 0 known failure, 0 skipped +[inst/@sym/intersect.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/intersect.m ***** test A = sym([1 2 3]); B = sym([1 2 4]); - C = union(A, B); - D = sym([1 2 3 4]); + C = intersect(A, B); + D = sym([1 2]); assert (isequal (C, D)) ***** test % one nonsym A = sym([1 2 3]); B = [1 2 4]; - C = union(A, B); - D = sym([1 2 3 4]); + C = intersect(A, B); + D = sym([1 2]); assert (isequal (C, D)) ***** test % empty A = sym([1 2 3]); - C = union(A, A); - assert (isequal(C, A)) + C = intersect(A, A); + assert (isequal (C, A)) ***** test % empty input A = sym([1 2]); - C = union(A, []); - assert (isequal (C, sym([1 2]))) + C = intersect(A, []); + assert (isempty (C)) ***** test % scalar syms x - assert (isequal (union([x 1], x), [1 x])) - assert (isequal (union(x, x), x)) + assert (isequal (intersect([x 1], x), x)) + assert (isequal (intersect(x, x), x)) ***** test A = interval(sym(1), 3); B = interval(sym(2), 5); - C = union(A, B); - assert( isequal( C, interval(sym(1), 5))) + C = intersect(A, B); + assert( isequal( C, interval(sym(2), 3))) 6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@sym/isprime.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isprime.m -***** assert (isprime (sym(5))) -***** assert (~isprime (sym(4))) -***** assert (~isprime (sym(0))) -***** assert (~isprime (sym(1))) -***** test - a = [5 7 6; 1 2 337]; - assert (isequal (isprime (a), [true true false; false true true])) -***** assert (~isprime(sym(-4))) -***** assert (~isprime(sym(4i))) -***** assert (~isprime(sym(3)/5)) -***** error - isprime(sym('x')); -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/ei.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ei.m -***** test - syms x - f = ei(sym(0)); - assert (double(f) == -inf) -***** test - D = [1.895117816355937 4.954234356001890]; - A = ei(sym([1 2])); - assert (all (abs(double(A) - D) < 1e-15)) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/min.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/min.m -***** test - % scalars with dim - a = min(sym(pi), [], 1); - b = sym(pi); - assert (isequal (a, b)); - a = min(sym(pi), [], 2); - assert (isequal (a, b)); - a = max(sym(pi), [], 1); - assert (isequal (a, b)); - a = max(sym(pi), [], 2); - assert (isequal (a, b)); -***** shared A, D - D = [0 1 2 3]; - A = sym(D); -***** test - % row vectors - assert (isequal (min(A), sym(min(D)))) - assert (isequal (min(A), sym(0))) - assert (isequal (max(A), sym(max(D)))) - assert (isequal (max(A), sym(3))) -***** test - % row vectors with dim - assert (isequal (min(A, [], 1), sym(min(D, [], 1)))) - assert (isequal (min(A, [], 2), sym(min(D, [], 2)))) - assert (isequal (max(A, [], 1), sym(max(D, [], 1)))) - assert (isequal (max(A, [], 2), sym(max(D, [], 2)))) -***** test - % column vectors - A = A.'; - D = D.'; - assert (isequal (min(A), sym(min(D)))) - assert (isequal (min(A), sym(0))) - assert (isequal (max(A), sym(max(D)))) - assert (isequal (max(A), sym(3))) -***** test - % row vectors with dim - assert (isequal (min(A, [], 1), sym(min(D, [], 1)))) - assert (isequal (min(A, [], 2), sym(min(D, [], 2)))) - assert (isequal (max(A, [], 1), sym(max(D, [], 1)))) - assert (isequal (max(A, [], 2), sym(max(D, [], 2)))) -***** shared -***** test - % empty - a = min(sym([])); - assert(isempty(a)) - a = max(sym([])); - assert(isempty(a)) -***** test - % matrix - A = [1 4 6; 2 2 5]; - A = sym(A); - assert (isequal (min(A), sym([1 2 5]))) - assert (isequal (min(A, [], 1), sym([1 2 5]))) - assert (isequal (min(A, [], 2), sym([1; 2]))) - assert (isequal (max(A), sym([2 4 6]))) - assert (isequal (max(A, [], 1), sym([2 4 6]))) - assert (isequal (max(A, [], 2), sym([6; 5]))) -***** test - % index output is double not sym - [m, I] = min(sym(2), [], 1); - assert (strcmp(class(I), 'double')) - [m, I] = max(sym(2), [], 1); - assert (strcmp(class(I), 'double')) -***** test - % empty rows/columns, I is double - A = sym(zeros(0, 4)); - [m, I] = min(A, [], 1); - assert (strcmp(class(I), 'double')) - [m, I] = max(A, [], 1); - assert (strcmp(class(I), 'double')) - A = sym(zeros(3, 0)); - [m, I] = min(A, [], 2); - assert (strcmp(class(I), 'double')) - [m, I] = max(A, [], 2); - assert (strcmp(class(I), 'double')) -***** test - % index output - A = [0 1 9; 10 7 4]; - B = sym(A); - [m1, I1] = min(A); - [m2, I2] = min(B); - assert (isequal (I1, I2)) - assert (isequal (m1, double(m2))) - [m1, I1] = max(A); - [m2, I2] = max(B); - assert (isequal (I1, I2)) - assert (isequal (m1, double(m2))) -***** test - % index output, with dim - A = [0 1 9; 10 7 4]; - B = sym(A); - [m1, I1] = min(A, [], 1); - [m2, I2] = min(B, [], 1); - assert (isequal (I1, I2)) - assert (isequal (m1, double(m2))) - [m1, I1] = min(A, [], 2); - [m2, I2] = min(B, [], 2); - assert (isequal (I1, I2)) - assert (isequal (m1, double(m2))) - [m1, I1] = max(A, [], 1); - [m2, I2] = max(B, [], 1); - assert (isequal (I1, I2)) - assert (isequal (m1, double(m2))) - [m1, I1] = max(A, [], 2); - [m2, I2] = max(B, [], 2); - assert (isequal (I1, I2)) - assert (isequal (m1, double(m2))) -***** test - % empty columns - A = sym(zeros(0, 4)); - [m, I] = min(A, [], 1); - assert (isequal (size(m), [0 4])) - assert (isequal (size(I), [0 4])) - [m, I] = max(A, [], 1); - assert (isequal (size(m), [0 4])) - assert (isequal (size(I), [0 4])) -***** test - % empty rows - A = sym(zeros(3, 0)); - [m, I] = min(A, [], 2); - assert (isequal (size(m), [3 0])) - assert (isequal (size(I), [3 0])) - [m, I] = max(A, [], 2); - assert (isequal (size(m), [3 0])) - assert (isequal (size(I), [3 0])) -***** test - % another empty case - % we differ slightly from double which gives 1x0/0x1 - A = sym(zeros(3, 0)); - [m, I] = min(A, [], 1); - assert (isempty (m)) - assert (isempty (I)) - A = sym(zeros(0, 3)); - [m, I] = min(A, [], 2); - assert (isempty (m)) - assert (isempty (I)) -***** test - % empty without index output - A = sym(zeros(3, 0)); - assert (isempty (min (A, [], 1))) - assert (isempty (max (A, [], 1))) - assert (isempty (min (A, [], 2))) - assert (isempty (max (A, [], 2))) - A = sym(zeros(0, 3)); - assert (isempty (min (A, [], 1))) - assert (isempty (max (A, [], 1))) - assert (isempty (min (A, [], 2))) - assert (isempty (max (A, [], 2))) -***** test - % binary op form, one a scalar - A = sym([3 1 9]); - m = min(A, sym(2)); - M = max(A, sym(2)); - assert (isequal (m, sym([2 1 2]))) - assert (isequal (M, sym([3 2 9]))) - m = min(sym(2), A); - M = max(sym(2), A); - assert (isequal (m, sym([2 1 2]))) - assert (isequal (M, sym([3 2 9]))) -***** test - % binary op form, both scalar - m = min(sym(1), sym(2)); - M = max(sym(2), sym(2)); - assert (isequal (m, sym(1))) - assert (isequal (M, sym(2))) -***** test - syms x y - assert (isequal (children (min (x, y)), [x y])) -***** test - syms x y z - A = [x 1; y z]; - assert (isequal (min (A, [], 1), [min(x, y) min(1, z)])) - assert (isequal (max (A, [], 1), [max(x, y) max(1, z)])) - assert (isequal (min (A, [], 2), [min(x, 1); min(y, z)])) - assert (isequal (max (A, [], 2), [max(x, 1); max(y, z)])) -***** test - syms x y positive - a = min([x 2 y -6]); - assert (isequal (a, -6)) - a = max([x y -6]); - assert (isequal (a, max(x, y))) -***** test - syms x negative - a = min([x 6 10]); - assert (isequal (a, x)) - a = max([x -2 6]); - assert (isequal (a, 6)) -21 tests, 21 passed, 0 known failure, 0 skipped -[inst/@sym/nnz.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/nnz.m -***** assert (nnz (sym ([1])) == 1) -***** assert (nnz (sym ([0])) == 0) -***** assert (nnz (sym ([])) == 0) -***** assert (nnz (sym ([1 0; 0 3])) == 2) -***** test - syms x - assert (nnz ([x 0]) == 1) -***** assert (nnz (sym (true)) == 1) -***** assert (nnz (sym (false)) == 0) -***** assert (nnz (sym (inf)) == 1) -***** assert (nnz (sym (nan)) == 1) -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/coeffs.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/coeffs.m -***** error coeffs (sym(1), 2, 3, 4) -***** error coeffs (sym(1), 2, 'al') -***** error coeffs (sym(1), 'al') +[inst/@sym/gt.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/gt.m ***** test % simple - syms x - [c, t] = coeffs(6*x*x + 27); - assert (isequal (c, [6 27])) - assert (isequal (t, [x*x 1])) -***** test - % specify a variable - syms x - [c, t] = coeffs(6*x*x + 27, x); - assert (isequal (c, [6 27])) - assert (isequal (t, [x*x 1])) -***** test - % specify another variable - syms x y - [c, t] = coeffs(6*x + 27, y); - assert (isequal (c, 6*x + 27)) - assert (isequal (t, 1)) -***** test - % weird SMT order - syms x - a1 = [27 6]; - a2 = [6 27]; - c = coeffs(6*x*x + 27); - assert (isequal (c, a1)) - coeffs(6*x*x + 27); - assert (isequal (ans, a1)) - [c, t] = coeffs(6*x*x + 27); - assert (isequal (c, a2)) -***** test - % no weird order with "all" - syms x - c = coeffs(6*x*x + 27, 'all'); - assert (isequal (c, [6 0 27])) -***** test - % "all" - syms x - [c, t] = coeffs(6*x*x + 27, 'all'); - assert (isequal (c, [6 0 27])) - assert (isequal (t, [x^2 x 1])) -***** test - % "All" - syms x - [c, t] = coeffs(6*x, 'All'); - assert (isequal (c, [6 0])) - assert (isequal (t, [x 1])) -***** test - % multivariable array - syms x y - [c, t] = coeffs(6*x*x + 27*y*x + 36, [x y]); - a = [6 27 36]; - s = [x^2 x*y 1]; - assert (isequal (c, a)) - assert (isequal (t, s)) - % with list - [c, t] = coeffs(6*x*x + 27*y*x + 36, {x y}); - assert (isequal (c, a)) - assert (isequal (t, s)) -***** test - % other symbols treated as part of coeffs - syms x y - [c, t] = coeffs(6*x*x + 27*y*x + 36, x); - a = [6 27*y 36]; - s = [x^2 x 1]; - assert (isequal (c, a)) - assert (isequal (t, s)) -***** error - % TODO: multivariate all not working (https://github.com/gnu-octave/symbolic/issues/720) - syms x y - [c, t] = coeffs(6*x^2 + 7*y + 19, [x y], 'all'); -***** test - % empty same as not specifying; maybe not SMT compatible: - % https://github.com/gnu-octave/symbolic/pull/708#discussion_r94292831 - syms x y - [c, t] = coeffs(6*x*x + 27*y*x + 36, {}); - a = [6 27 36]; - assert (isequal (c, a)) - [c, t] = coeffs(6*x*x + 27*y*x + 36); - assert (isequal (c, a)) -***** test - % no input defaults to all symbols (not symvar to get x) - syms x y - [c, t] = coeffs(6*x*x + 27*y*x + 36); - assert (isequal (c, [6 27 36])) -***** test - % non sym input - syms x - assert (isequal (coeffs(6, x), sym(6))) -***** test - % constant input without x - assert (isequal (coeffs(sym(6)), sym(6))) -***** test - % constant input without x - assert (isequal (coeffs (sym(6), {}), sym(6))) - % irrational coefficients - syms x - f = x^2 + sqrt(sym(2))*x; - [c1, t1] = coeffs (f); - [c2, t2] = coeffs (f, x); - assert (isequal (c1, c2)) - assert (isequal (t1, t2)) -18 tests, 18 passed, 0 known failure, 0 skipped -[inst/@sym/cat.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cat.m -***** test - % mostly tested in horzcat, vertcat: one for good measure - syms x - assert (isequal (cat(1, x, x), [x x])) - assert (isequal (cat(2, x, x), [x; x])) -***** error cat(3, sym(2), sym(3)) -***** error cat(0, sym(2), sym(3)) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/subsasgn.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/subsasgn.m -***** shared a,b - b = [1:4]; - a = sym(b); -***** test a(1) = 10; b(1) = 10; - assert(isequal( a, b )) -***** test I = logical([1 0 1 0]); - a(I) = 2; b(I) = 2; - assert(isequal( a, b )) -***** test I = logical([1 0 1 0]); - a(I) = [2 4]; b(I) = [2 4]; - assert(isequal( a, b )) -***** test I = logical([1 0 1 0]); - a(I) = [2; 4]; b(I) = [2; 4]; - assert(isequal( a, b )) -***** shared -***** test - b = 1:4; b = [b; 2*b; 3*b]; - a = sym(b); - rhs = [10 11; 12 13]; - a([1:2],[1:2]) = rhs; - b([1:2],[1:2]) = rhs; - assert(isequal( a, b )) - a(1:2,1:2) = rhs; - assert(isequal( a, b )) -***** test - % slice : - b = 1:4; b = [b; 2*b]; - a = sym(b); - rhs = [10 11; 12 13]; - a(:,2:3) = rhs; - b(:,2:3) = rhs; - assert(isequal( a, b )) -***** test - % grow 2D - b = 1:4; b = [b; 2*b]; - a = sym(b); - rhs = [10 11; 12 13]; - a([1 end+1],end:end+1) = rhs; - b([1 end+1],end:end+1) = rhs; - assert(isequal( a, b )) -***** test - % grow from nothing - clear a - a(3) = sym (1); - b = sym ([0 0 1]); - assert (isequal (a, b)) -***** test - % grow from nothing, 2D - clear a - a(2, 3) = sym (1); - b = sym ([0 0 0; 0 0 1;]); - assert (isequal (a, b)) -***** test - % linear indices of 2D - b = 1:4; b = [b; 2*b; 3*b]; - a = sym(b); - b(1:4) = [10 11 12 13]; - a(1:4) = [10 11 12 13]; - assert(isequal( a, b )) - b(1:4) = [10 11; 12 13]; - a(1:4) = [10 11; 12 13]; - assert(isequal( a, b )) -***** error - % Wrong shape matrix RHS: Matlab/Octave don't allow this on doubles. - % Matlab SMT 2013b gets it wrong. We throw an error. - rhs = [10 11; 12 13]; - a = sym (magic (3)); - a(1:2,1:2) = rhs(:); -***** test - % Issue #963: vector RHS with diff orientation from 2D indexing - b = 1:4; b = [b; 2*b; 3*b]; - a = sym(b); - b(1:2:3, 1) = 11:2:13; - a(1:2:3, 1) = sym(11:2:13); - assert (isequal (a, b)) - b(1:2:3, 1) = 1:2:3; - a(1:2:3, 1) = 1:2:3; - assert (isequal (a, b)) -***** test - % Issue #963: vector RHS with diff orientation from 2D indexing - a = sym (magic (3)); - b = a; - a(1:2:3, 2) = [14 15]; - b(1:2:3, 2) = [14; 15]; - assert (isequal (a, b)) - a(2, 1:2:3) = [24 25]; - b(2, 1:2:3) = [24; 25]; - assert (isequal (a, b)) -***** test - % 1D growth and 'end' - g = sym([1 2 3]); - g(3:4) = [67 68]; - g(end:end+1) = [12 14]; - assert(isequal( g, [1 2 67 12 14] )) -***** test - % expanding empty and scalar - syms x - c = sym([]); - c(1) = x; - assert(isequal( c, x )) - c(2) = 2*x; - assert(isequal( c, [x 2*x] )) -***** shared a,b,I,J - b = 1:4; b = [b; 3*b; 5*b]; a = sym(b); - I = logical([1 0 1]); - J = logical([1 0 1 0]); -***** assert(isequal( a(I,J), b(I,J) )) -***** test - rhs = [90 91; 92 93]; - b(I, J) = rhs; - a(I, J) = rhs; - assert(isequal( a, b )) -***** test - b(I, J) = 100; - a(I, J) = 100; - assert(isequal( a, b )) -***** shared -***** test - % logical with all false - syms x - y = x; - y(false) = 6; - assert(isequal( y, x )); - a = [x x]; - a([false false]) = [6 6]; - assert(isequal( a, [x x] )); -***** test - % issue #18, scalar access - syms x - x(1) = sym(6); - assert(isequal( x, sym(6) )); - x(1) = 6; - assert(isequal( x, sym(6) )); - x(true) = 88; - assert(isequal( x, sym(88) )); -***** test - % bug: assignment to column vector used to fail - A = sym(zeros(3,1)); - A(1) = 5; -***** test - % symfun creation (generic function) - syms x - g(x) = x*x; - assert(isa(g,'symfun')) -***** test - % symfun creation (generic function) - syms x g(x) - assert(isa(g,'symfun')) -***** test - % symfun creation when g already exists and is a sym/symfun - syms x - g = x; - syms g(x) - assert(isa(g,'symfun')) - clear g - g(x) = x; - g(x) = x*x; - assert(isa(g,'symfun')) -***** test - % Issue #443: assignment with sym indices - A = sym([10 11]); - A(sym(1)) = 12; - assert (isequal (A, sym([12 11]))) -***** test - % Issue #443: assignment with sym indices - A = sym([10 11]); - A(sym(1), 1) = 12; - assert (isequal (A, sym([12 11]))) - A(sym(1), sym(1)) = 13; - assert (isequal (A, sym([13 11]))) -***** test - % Issue #443: assignment with sym indices, increase size - A = sym([10 11]); - A(sym(2), 1) = 12; - assert (isequal (A, sym([10 11; 12 0]))) -***** error - % Issue #443 - A = sym([10 11]); - A(2, sym('x')) = sym(12); -***** error - % Issue #443 - A = sym([10 11]); - A(sym(2), sym('x')) = sym(12); -***** error - % issue #445 - A = sym([10 11]); - A(1.1) = 13 -***** error - % issue #445 - A = sym([10 11]); - A(sym(pi)) = 13 -***** error - % issue #445 - A = sym([1 2; 3 4]); - A(1.3, 1.2) = 13 -***** test - % older expansion tests - syms x - f = [2*x 3*x]; - f(2) = 4*x; - assert (isequal (f, [2*x 4*x])) - f(2) = 2; - assert (isequal(f, [2*x 2])) - g = f; - g(1,3) = x*x; - assert (isequal(g, [2*x 2 x^2])) - g = f; - g(3) = x*x; - assert (isequal(g, [2*x 2 x^2])) - g = f; - g(3) = 4; - assert (isequal(g, [2*x 2 4])) -***** test - % older slicing tests - syms x - f = [1 x^2 x^4]; - f(1:2) = [x x]; - assert (isequal( f, [x x x^4] )) - f(1:2) = [1 2]; - assert (isequal( f, [1 2 x^4] )) - f(end-1:end) = [3 4]; - assert (isequal( f, [1 3 4] )) - f(3:4) = [10 11]; - assert (isequal( f, [1 3 10 11] )) - f(end:end+1) = [12 14]; - assert (isequal( f, [1 3 10 12 14] )) -***** test - % struct.str = sym, sometimes calls subsasgn - d = struct(); - syms x - d.a = x; - assert (isa (d, 'struct')) - assert (isequal (d.a, x)) - d.('a') = x; - assert (isa (d, 'struct')) - assert (isequal (d.a, x)) - d = setfield(d, 'a', x); - assert (isa (d, 'struct')) - assert (isequal (d.a, x)) - % at least on Oct 3.8, this calls sym's subsasgn - d = struct(); - d = setfield(d, 'a', x); - assert (isa (d, 'struct')) - assert (isequal (d.a, x)) -***** test - % bool scalar assignments of true/false into sym - syms x - a = sym([1 2 x 3]); - b = [1 2 10 4]; - e = a == b; - assert (logical (e(2))) - e(2) = false; - assert (~logical (e(2))) -***** test - % bool vector assignments of true/false into sym - syms x - a = sym([1 2 x 3]); - b = [1 2 10 4]; - e = a == b; - e(1:2) = [true true]; - assert (isequal (e, [sym(1)==1 sym(2)==2 x==10 sym(3)==4])) + x = sym(1); y = sym(1); e = x > y; + assert (~logical (e)) + x = sym(1); y = sym(2); e = x > y; + assert (~logical (e)) ***** test - % bool scalar promoted to vector assignments into sym + % array -- array syms x - a = sym([1 2 x 3]); - b = [1 2 10 4]; - e = a == b; - e(1:2) = true; - assert (isequal (e, [sym(1)==1 sym(2)==2 x==10 sym(3)==4])) -***** test - % grow scalar equality expression into a matrix of equalities - syms a b c d - e = a == b; - e(2) = c == d; - assert (isequal (e, [a==b c==d])) -***** shared a, b, I - b = [1:4]; b = [b; 3*b; 5*b]; - a = sym(b); - I = mod (b, 5) > 1; -***** test - A = a; A(I) = 2*b(I); - B = b; B(I) = 2*b(I); - assert (isequal (A, B)) -***** test - % scalar RHS - A = a; A(I) = 17; - B = b; B(I) = 17; - assert (isequal (A, B)) -***** test - % nonetheless, above strange case should give right answer - I = logical([1 0 1 0; 0 1 0 1; 1 0 1 0]); - rhs = 2*b(I); - rhs2 = reshape(rhs, 2, 3); - A0 = a; A1 = a; - A0(I) = rhs; - A1(I) = rhs2; - assert (isequal (A0, A1)) -***** shared AA, BB - BB = [1 2 3; 4 5 6]; - AA = sym(BB); -***** test - A = AA; B = BB; - B([1 6]) = [8 9]; - A([1 6]) = [8 9]; - assert (isequal (A, B)) -***** test - % rhs scalar - A = AA; B = BB; - B([1 6]) = 88; - A([1 6]) = 88; - assert (isequal (A, B)) -***** test - % If rhs is not a vector, make sure col-based access works - rhs = [18 20; 19 21]; - A = AA; B = BB; - B([1 6]) = 88; - A([1 6]) = 88; - B([1 2 3 4]) = rhs; - A([1 2 3 4]) = rhs; - assert (isequal (A, B)) -***** test - % Growth - A = AA; B = BB; - A(1,5) = 10; - B(1,5) = 10; - assert (isequal (A, B)) -***** shared -***** test - % Check row deletion 1D - a = sym([1; 3; 5]); - b = sym([3; 5]); - a(1) = []; - assert( isequal( a, b)) -***** test - % Check column deletion 1D - a = sym([1, 4, 8]); - b = sym([4, 8]); - a(1) = []; - assert( isequal( a, b)) -***** test - % Check row deletion 2D - a = sym([1, 2; 3, 4]); - b = sym([3, 4]); - a(1, :) = []; - assert( isequal( a, b)) -***** test - % Check column deletion 2D - a = sym([1, 2; 3, 4]); - b = sym([2; 4]); - a(:, 1) = []; - assert( isequal( a, b)) -***** test - % General assign - a = sym([1, 2; 3, 4]); - b = sym([5, 5; 5, 5]); - a(:) = 5; - assert( isequal( a, b)) -***** test - % Empty matrix - a = sym([1, 2; 3, 4]); - a(:) = []; - assert( isequal( a, sym([]))) -***** test - % Disassemble matrix - a = sym([1 2; 3 4; 5 6]); - b = sym([3 5 2 4 6]); - a(1) = []; - assert (isequal (a, b)); -***** error - a = sym([1, 2; 3, 4]); - a(1, 2) = []; -***** test - % Issue #964 - a = sym(10); - a(1) = []; - assert (isempty (a)) - assert (isequal (a, zeros(1, 0))) -***** test - % Issue #963: scalar asgn to empty part of matrix - A = sym (magic (3)); - B = A; - A(1, []) = 42; - assert (isequal (A, B)) - A([], 2) = 42; - assert (isequal (A, B)) - A([]) = 42; - assert (isequal (A, B)) - A([], []) = 42; - assert (isequal (A, B)) - A(2:3, []) = 42; - assert (isequal (A, B)) - A([], 2:3) = 42; - assert (isequal (A, B)) - A(:, []) = 42; - assert (isequal (A, B)) - A([], :) = 42; - assert (isequal (A, B)) -***** test - % Issue #1026 - a = sym(1:5); - a(1:3) = []; - assert (isequal (a, sym([4 5]))) -***** test - % Issue #1026 - B = eye(4); - A = sym(B); - A(1:2, :) = []; - B(1:2, :) = []; - assert (isequal (A, B)) -***** error - % TODO: do we care what error? - A = sym (magic (3)); - A(2:3, []) = [66; 66]; -***** error - A = sym (magic (3)); - A([]) = [66; 66]; -***** error - A = sym (magic (3)); - A([], 1) = [66; 66]; -***** test - % Issue #966: empty indexing, empty RHS, A unchanged - B = magic(3); - A = sym(B); - A(1, []) = []; - assert (isequal (A, B)) - A([], 2) = []; - assert (isequal (A, B)) - A([], []) = []; - assert (isequal (A, B)) - A(2:3, []) = []; - assert (isequal (A, B)) - A([], 2:3) = []; - assert (isequal (A, B)) - A(:, []) = []; - assert (isequal (A, B)) - A([], :) = []; - assert (isequal (A, B)) -***** test - % Issue 967 - B = [1 2; 3 4]; - A = sym(B); - A([]) = []; - assert (isequal (A, B)) -***** test - % Issue #965 - a = sym(7); - a([]) = []; - assert (isequal (a, sym(7))) -***** test - % Issue #965 - a = sym(7); - a([]) = 42; - assert (isequal (a, sym(7))) -***** error - % Issue #965 - a = sym(7); - a([]) = [42 42] + a = sym([1 3 3 2*x]); + b = sym([2 x 3 10]); + e = a > b; + assert (isa (e, 'sym')) + assert (~logical (e(1))) + assert (isa (e(2), 'sym')) + assert (isequal (e(2), 3 > x)) + assert (~logical (e(3))) + assert (isa (e(4), 'sym')) + assert (isequal (e(4), 2*x > 10)) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/power.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/power.m ***** test - b = eye (3); - a = sym (b); - I = [2 3; 4 5]; - a(I) = -2*I; - b(I) = -2*I; - assert (isequal (a, sym (b))); - assert (size (a), [3 3]); -***** error + % scalar .^ scalar syms x - A = [1 x; x 2]; - A(5) = x; -***** test - % 2D indexing with length in one dimension more than 2 - a = sym ([1 2; 3 4; 5 6]); - indices = [1 4; 2 5; 3 6]; - b = [10 11; 12 13; 14 15]; - a(indices) = b; - assert (isequal (a, sym (b))); -***** test - A = sym ([0 0 0]); - indices = [false true false]; - A(indices) = 1; - assert (isequal (A, sym ([0 1 0]))); - A(indices) = []; - assert (isequal (A, sym ([0 0]))); - indices = [false false]; - A(indices) = []; - assert (isequal (A, sym ([0 0]))); -***** shared a, b - a = [1 2 3 5; 4 5 6 9; 7 5 3 2]; - b = sym (a); -***** test - A = a; B = b; - A(true) = 0; - B(true) = 0; - assert (isequal (A, B)) -***** test - A = a; B = b; - A(false) = 0; - B(false) = 0; - assert (isequal (A, B)) -***** test - c = [false true]; - A = a; B = b; - A(c) = 0; B(c) = 0; - assert (isequal (A, B)) - d = c | true; - A(d) = 1; B(d) = 1; - assert (isequal (A, B)) - d = c & false; - A(d) = 2; B(d) = 2; - assert (isequal (A, B)) -***** test - c = [false true false true; true false true false; false true false true]; - A = a; B = b; - A(c) = 0; B(c) = 0; - assert (isequal (A, B)) - d = c | true; - A(d) = 1; B(d) = 1; - assert (isequal (A, B)) - d = c & false; - A(d) = 2; B(d) = 2; - assert (isequal (A, B)) -***** test - c = [false true false true false]; - A = a; B = b; - A(c) = 0; B(c) = 0; - assert (isequal (A, B)) - d = c | true; - A(d) = 1; B(d) = 1; - assert (isequal (A, B)) - d = c & false; - A(d) = 2; B(d) = 2; - assert (isequal (A, B)) + assert (isa (x.^2, 'sym')) + assert (isa (2.^x, 'sym')) + assert (isa (x.^x, 'sym')) + assert (isequal (x.^2, x^2)) + assert (isequal (2.^x, 2^x)) + assert (isequal (x.^x, x^x)) ***** test - c = [false; true; false; true; false]; - A = a; B = b; - A(c) = 0; B(c) = 0; - assert (isequal (A, B)) - d = c | true; - A(d) = 1; B(d) = 1; - assert (isequal (A, B)) - d = c & false; - A(d) = 2; B(d) = 2; - assert (isequal (A, B)) + % scalar .^ matrix + D = [0 1; 2 3]; + A = sym(D); + assert (isequal ( sym(2).^D , 2.^D )) + assert (isequal ( sym(2).^A , 2.^A )) + assert (isequal ( 2.^D , 2.^A )) + assert (isequal ( 2.^A , 2.^A )) ***** test - c = [false true; false true; true false]; - A = a; B = b; - A(c) = 0; B(c) = 0; - assert (isequal (A, B)) - d = c | true; - A(d) = 1; B(d) = 1; - assert (isequal (A, B)) - d = c & false; - A(d) = 2; B(d) = 2; - assert (isequal (A, B)) -77 tests, 77 passed, 0 known failure, 0 skipped -[inst/@sym/arg.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/arg.m + % matrix .^ matrix + syms x + A = [x 2*x; 3*x 4*x]; + D = [0 1; 2 3]; + B = sym(D); + assert (isequal ( A.^D, [1 2*x; 9*x^2 64*x^3] )) + assert (isequal ( A.^B, [1 2*x; 9*x^2 64*x^3] )) ***** test + % matrix .^ scalar syms x - assert (isequal (angle (x), arg (x))); -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@sym/eval.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/eval.m -***** error eval (sym(1), 2) -***** assert (isnumeric (eval (sym(3)))) -***** assert (isnumeric (eval (sin (sym(3))))) + A = [x 2*x]; + assert (isequal ( A.^2, [x^2 4*x^2] )) + assert (isequal ( A.^sym(2), [x^2 4*x^2] )) ***** test - syms x y - f = 2*x*y; - x = 3; - y = 4; - g = eval (f); - assert (isequal (g, 24)) + % 1^oo + % (sympy >= 0.7.5 gives NaN, SMT R2013b: gives 1) + oo = sym(inf); + assert (isnan (1^oo)) ***** test - syms x y - f = 2*x*y; - clear y - x = 3; - g = eval (f); - assert (isequal (g, 6*sym('y'))) + % 1^zoo + % (1 on sympy 0.7.4--0.7.6, but nan in git (2014-12-12, a210908d4)) + zoo = sym('zoo'); + assert (isnan (1^zoo)) ***** test - % do not convert inputs to sym, for SMT compat - nearpi = pi + 1e-14; % sym could make this pi - x = sym('x'); - f = 2*x; - x = nearpi; - d = eval (f); - assert (abs (d - 2*pi) > 1e-15) -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@sym/prod.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/prod.m -***** error prod (sym(1), 2, 3) -***** error prod (sym(1), 42) + % immutable test + A = sym([1 2]); + B = sym('ImmutableDenseMatrix([[Integer(1), Integer(2)]])'); + assert (isequal (A.^A, B.^B)) +7 tests, 7 passed, 0 known failure, 0 skipped +[inst/@sym/curl.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/curl.m +***** error curl([sym(1) 2 3], 42, 42) ***** shared x,y,z syms x y z -***** assert (isequal (prod (x), x)) -***** assert (isequal (prod ([x y z]), x*y*z)) -***** assert (isequal (prod ([x; y; z]), x*y*z)) -***** assert (isequal (prod ([x y z], 1), [x y z])) -***** assert (isequal (prod ([x y z], 2), x*y*z)) -***** shared a,b - b = [1 2; 3 4]; a = sym(b); -***** assert (isequal (prod(a), prod(b))) -***** assert (isequal (prod(a,1), prod(b,1))) -***** assert (isequal (prod(a,2), prod(b,2))) ***** test - % weird inputs - a = prod('xx', sym(1)); - assert (isequal (a, sym('xx'))) -11 tests, 11 passed, 0 known failure, 0 skipped + % double const + f = [1 2 3]; + g = [sym(0); 0; 0]; + assert (isequal (curl(f, [x y z]), g)) + % should fail, calls @double: curl(f, {x y z}), g)) +***** test + % div curl always 0 + v = [exp(x); x*y; sin(z)]; + g = curl(v); + a = divergence(g, [x y z]); + assert (isAlways (a == sym(0))) + assert (isa (a, 'sym')) + g = curl(v, [x y z]); + a = divergence(g, [x y z]); + assert (isAlways (a == sym(0))) + assert (isa (a, 'sym')) +***** test + % div curl always 0 + v = [exp(x); erfc(x*y); sin(exp(x)*y+sinh(z))]; + g = curl(v, [x y z]); + a = divergence(g, [x y z]); + assert (isAlways (a == sym(0))) + assert (isa (a, 'sym')) +***** test + % curl grad is vec zero + f = sin(exp(x)*y+sinh(z)); + g = curl(gradient(f, [x,y,z])); + assert (isequal (g, sym([0;0;0]))) +***** test + % 2d fcn in 2d/3d + u = sin(exp(x)*y); + v = x^2*y^3; + vorticity2d = diff(v,x) - diff(u,y); + omega = curl([u; v; 0], [x y z]); + assert (isequal (omega, [0; 0; vorticity2d])) +***** error <3D vector> curl([sym(1) 2 3 4]) +***** error curl([sym(1) 2 3], {sym('x') sym('y') sym('z') sym('t')}) +8 tests, 8 passed, 0 known failure, 0 skipped [inst/@sym/xor.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/xor.m ***** shared t, f @@ -10672,474 +11171,508 @@ assert (isequal (subs(e, x, [-3 0 3]), [t f f])) ***** error xor (sym('x'), 1, 2) 6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@sym/sec.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sec.m -***** error sec (sym(1), 2) -***** assert (isequaln (sec (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); +[inst/@sym/trace.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/trace.m ***** test - f1 = sec(x); - f2 = sec(d); - assert( abs(double(f1) - f2) < 1e-15 ) + % scalar + syms x + assert (isequal (trace(x), x)) ***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = sec(A); - f2 = sec(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) + syms x + A = [x 3; 2*x 5]; + assert (isequal (trace(A), x + 5)) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/or.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/or.m +***** shared t, f + t = sym(true); + f = sym(false); ***** test - % round trip - y = sym('y'); - A = sec (d); - f = sec (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/divisors.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/divisors.m + % simple + assert (isequal (t | f, t)) + assert (isequal (t | t, t)) + assert (isequal (f | f, f)) ***** test - assert( isequal( divisors(sym(150)), divisors(sym(-150)) )) -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@sym/sign.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sign.m -***** error sign (sym(1), 2) -***** assert (isequaln (sign (sym(nan)), sym(nan))) + % array + w = [t t f f]; + z = [t f t f]; + assert (isequal (w | z, [t t t f])) +***** test + % output is sym even for scalar t/f + assert (isa (t | f, 'sym')) +***** test + % eqns + syms x + e = or(x == 4, x == 5); + assert (isequal (subs(e, x, [3 4 5 6]), [f t t f])) +***** error or (sym(1), 2, 3) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/sinh.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sinh.m +***** error sinh (sym(1), 2) +***** assert (isequaln (sinh (sym(nan)), sym(nan))) ***** shared x, d d = 1; x = sym('1'); ***** test - f1 = sign(x); - f2 = sign(d); + f1 = sinh(x); + f2 = sinh(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = sign(A); - f2 = sign(D); + f1 = sinh(A); + f2 = sinh(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = sign (d); - f = sign (y); + A = sinh (d); + f = sinh (y); h = function_handle (f); B = h (d); assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/children.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/children.m -***** test - % basics, sum - syms x y - f = 2*x + x*x + sin(y); - assert (isempty (setxor (children(f), [2*x x*x sin(y)]))) +[inst/@sym/horner.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/horner.m +***** error horner (sym(1), 2, 3) +***** assert (isAlways (horner(sym(1)) == 1)) ***** test - % basics, product - syms x y - f = 2*x*sin(y); - assert (isempty (setxor (children(f), [2 x sin(y)]))) + syms x + assert (isAlways (horner(x) == x)) ***** test - % basics, product and powers - syms x y - f = 2*x^2*y^3; - assert (isempty (setxor (children(f), [2 x^2 y^3]))) + syms x a + p = a^2 + a*x + 2*a + 2*x; + assert (isequal (horner (p, a), a*(a+x+2) + 2*x)) + q = a^2 + 2*a + x*(a + 2); + assert (isequal (horner (p, x), q)) + assert (isequal (horner (p), q)) ***** test - % eqn, ineq - syms x y - lhs = 2*x^2; rhs = y^3 + 7; - assert (isequal (children(lhs == rhs), [lhs rhs])) - assert (isequal (children(lhs < rhs), [lhs rhs])) - assert (isequal (children(lhs >= rhs), [lhs rhs])) + syms x + p = poly2sym ([2 4 6 8], x); + q = horner (p); + assert (isAlways (p == q)) + assert (isAlways (horner(2*x^3 + 4*x^2 + 6*x + 8) == q)) ***** test - % matrix - syms x y - f = [4 + y 1 + x; 2 + x 3 + x]; - c = children(f); - ec = {[4 y], [1 x]; [2 x], [3 x]}; - assert (isequal (size(c), size(ec))) - for i=1:length(c) - assert (isempty (setxor (c{i}, ec{i}))) - end + % non-sym input + syms x + assert (isequal (horner(6, x), sym(6))) +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@sym/ezsurf.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ezsurf.m +***** error + syms u v t + ezsurf(u*v, 2*u*v, 3*v*t) +***** error + syms u v t + ezsurf(u*v, 2*u*v, u*v*t) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/besselk.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/besselk.m ***** test - % matrix, sum/prod - syms x y - f = [x + y; x*sin(y); sin(x)]; - ec = {[x y]; [x sin(y)]; [x]}; - c = children(f); - assert (isequal (size(c), size(ec))) - for i=1:length(c) - assert (isempty (setxor (c{i}, ec{i}))) - end + X = [1 2 3; 4 5 6]; + ns = [sym(0) 1 -2; sym(1)/2 -sym(3)/2 pi]; + n = double(ns); + A = double(besselk(ns, X)); + B = besselk(n, X); + assert (all (all (abs (A - B) < 2*eps*abs(A)))) ***** test - % scalar symbol + % roundtrip syms x - assert (isequal (children(x), x)) + A = besselk(2, 10); + q = besselk(2, x); + h = function_handle(q); + B = h(10); + assert (abs (A - B) <= eps*abs(A)) +***** error besselk(sym('x')) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/linspace.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/linspace.m ***** test - % scalar number - x = sym(6); - assert (isequal (children(x), x)) + a = linspace(sym(3), 5, 5); + b = [sym(6) 7 8 9 10]/2; + assert (isequal (a, b)) ***** test - % symbolic size matrix - syms n m integer - A = sym('a', [n m]); - C = children (A); - assert (isequal (C(2), n)) - assert (isequal (C(3), m)) -***** xtest - % symbolic size matrix, fails on newer SymPy Issue #1089 - syms n m integer - A = sym('a', [n m]); - assert (isequal (children (A), [sym('a') n m])) -!!!!! known failure -assert (isequal (children (A), [sym('a'), n, m])) failed -10 tests, 9 passed, 1 known failure, 0 skipped -[inst/@sym/repmat.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/repmat.m + % non-integers + A = linspace(0, sym(pi), 10); + assert (length (A) == 10); + assert (isequal (A(6), 5*sym(pi)/9)); ***** test - % simple - syms x - A = [x x x; x x x]; - assert (isequal (repmat(x, 2, 3), A)) + % default argument for N + A = linspace(1, 100); + assert (length (A) == 100); ***** test - % block cf double - A = [1 2 3; 4 5 6]; - B = sym(A); - C = repmat(A, 2, 3); - D = repmat(B, 2, 3); - assert (isequal (C, D)) + % special case for just N = 1 + A = linspace(sym(2), 3, 1); + assert (isequal (A, 3)) + A = linspace(sym(2), 3, 0); + assert (isequal (A, 3)) + A = linspace(sym(2), 3, sym(3)/2); + assert (isequal (A, 3)) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/csch.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/csch.m +***** error csch (sym(1), 2) +***** assert (isequaln (csch (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); ***** test - % empty - A = repmat(sym([]), 2, 3); - assert (isempty(A)); - assert (isequal (size(A), [0 0])) + f1 = csch(x); + f2 = csch(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - % more empties - A = repmat(sym(pi), [0 0]); - assert (isequal (size(A), [0 0])) - A = repmat(sym(pi), [0 3]); - assert (isequal (size(A), [0 3])) - A = repmat(sym(pi), [2 0]); - assert (isequal (size(A), [2 0])) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/potential.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/potential.m -***** error potential (sym(1), 2, 3, 4) + D = [d d; d d]; + A = [x x; x x]; + f1 = csch(A); + f2 = csch(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) +***** test + % round trip + y = sym('y'); + A = csch (d); + f = csch (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/isvector.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isvector.m +***** assert(isvector(sym('x'))) +***** assert(isvector(sym([1 2 3]))) +***** assert(isvector(sym([1; 2]))) +***** assert(~isvector(sym([1 2; 3 4]))) +***** assert(~isvector(sym([]))) +***** assert(isvector(sym(ones(1,0)))) +***** assert(~isvector(sym(ones(0,3)))) +7 tests, 7 passed, 0 known failure, 0 skipped +[inst/@sym/function_handle.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/function_handle.m ***** shared x,y,z syms x y z ***** test - % 1D - f = 3*x^2; - F = x^3; - assert (isequal (potential(f), F)) - assert (isequal (potential(f, x), F)) - 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)) + % basic test + h = function_handle(2*x); + assert(isa(h, 'function_handle')) + assert(h(3)==6) ***** 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] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/laplace.m + % autodetect inputs + h = function_handle(2*x*y, x+y); + [t1, t2] = h(3,5); + assert(t1 == 30 && t2 == 8) ***** 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 )) + % specified inputs + h = function_handle(2*x*y, 'vars', [x y]); + assert(h(3,5)==30) + h = function_handle(2*x*y, x+y, 'vars', [x y]); + [t1, t2] = h(3,5); + assert(t1 == 30 && t2 == 8) ***** 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) )) + % cell arrays for vars list + h = function_handle(2*x*y, x+y, 'vars', {x y}); + [t1, t2] = h(3,5); + assert(t1 == 30 && t2 == 8) + h = function_handle(2*x*y, x+y, 'vars', {'x' 'y'}); + [t1, t2] = h(3,5); + assert(t1 == 30 && t2 == 8) ***** 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)) + % cell arrays specify order, overriding symvar order + h = function_handle(x*y, 12/y, 'vars', {y x}); + [t1, t2] = h(3, 6); + assert(t1 == 18 && t2 == 4) + h = function_handle(x*y, 12/y, 'vars', [y x]); + [t1, t2] = h(3, 6); + assert(t1 == 18 && t2 == 4) ***** test - syms x a s - % if no t, use symvar: take x before a - assert (isequal (laplace (a*exp (x)), a/(s - 1))) -***** error laplace (sym('t')*sym('t', 'real')) + % cell arrays specify order, overriding symvar order + h = function_handle(x*y, 12/y, 'vars', {y x}); + [t1, t2] = h(3, 6); + assert(t1 == 18 && t2 == 4) + h = function_handle(x*y, 12/y, 'vars', [y x]); + [t1, t2] = h(3, 6); + assert(t1 == 18 && t2 == 4) ***** test - % constant, issue #250 - syms s - f = laplace(2, s); - assert (isequal (f, 2/s)) + % Functions with different names in Sympy. + f = abs(x); % becomes Abs(x) + h = function_handle(f); + assert(h(-10) == 10) + f = ceil(x); + h = function_handle(f); + assert(h(10.1) == 11) ***** 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) )) + % 'file' with empty filename returns handle + h = function_handle(2*x*y, 'file', ''); + assert(isa(h, 'function_handle')) + assert(h(3,5)==30) + h = function_handle(2*x*y, 'vars', {x y}, 'file', ''); + assert(isa(h, 'function_handle')) + assert(h(3,5)==30) ***** 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)) + % output to disk + fprintf('\n') + if (exist ('OCTAVE_VERSION', 'builtin')) + temp_file = tempname('', 'oct_'); + else + temp_file = tempname(); end -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/besseljn.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/besseljn.m -***** test - % roundtrip - syms x - A = double(besseljn(sym(2), sym(9))); - q = besseljn(sym(2), x); - h = function_handle(q); - B = h(9); - assert (abs (A - B) <= eps) -***** error jn(sym('x')) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/lgamma.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/lgamma.m -***** test - % tested by gammaln - assert (isequal (lgamma (sym ('x')), gammaln (sym ('x')))) -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@sym/chebyshevT.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/chebyshevT.m -***** error chebyshevT (sym(1)) -***** error chebyshevT (sym(1), 2, 3) -***** assert (isequaln (chebyshevT (2, sym(nan)), sym(nan))) -***** shared x - syms x -***** assert(isequal(chebyshevT(0, x), sym(1))) -***** assert(isequal(chebyshevT(1, x), x)) -***** assert(isequal(chebyshevT(2, x), 2*x*x - 1)) -***** assert(isequal(chebyshevT([0 1 2], x), [sym(1) x (2*x*x-1)])) -***** test - % round trip - syms n z - f = chebyshevT (n, z); - h = function_handle (f, 'vars', [n z]); - A = h (1.1, 2.2); - B = chebyshevT (1.1, 2.2); - assert (A, B) -8 tests, 8 passed, 0 known failure, 0 skipped -[inst/@sym/zeros.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/zeros.m -***** test - y = zeros(sym(2)); - x = [0 0; 0 0]; - assert( isequal( y, sym(x))) -***** test - y = zeros(sym(2), 1); - x = [0; 0]; - assert( isequal( y, sym(x))) -***** test - y = zeros(sym(1), 2); - x = [0 0]; - assert( isequal( y, sym(x))) -***** test - y = zeros (sym([2 3])); - x = sym (zeros ([2 3])); - assert (isequal (y, x)) -***** assert( isa( zeros(sym(2), 'double'), 'double')) -***** assert( isa( zeros(3, sym(3), 'single') , 'single')) -***** assert( isa( zeros(3, sym(3)), 'sym')) -***** assert( isa( zeros(3, sym(3), 'sym'), 'sym')) -***** xtest - % Issue #13 - assert( isa( zeros(3, 3, 'sym'), 'sym')) -!!!!! known failure -invalid data type specified -9 tests, 8 passed, 1 known failure, 0 skipped -[inst/@sym/subs.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/subs.m -***** error subs (sym(1), 2, 3, 4) -***** shared x,y,t,f - syms x y t - f = x*y; + % allow loading function from temp_file + [temp_path, ans, ans] = fileparts(temp_file); + addpath(temp_path); + f = function_handle(2*x*y, 2^x, 'vars', {x y z}, 'file', temp_file); + assert( isa(f, 'function_handle')) + addpath(temp_path); % Matlab 2014a needs this? + [a,b] = f(10,20,30); + assert (isnumeric (a) && isnumeric (b)) + assert (a == 400) + assert (b == 1024) + if (exist ('OCTAVE_VERSION', 'builtin')) + assert (unlink([temp_file '.m']) == 0) + else + delete ([temp_file '.m']) + end + % remove temp_path from load path + rmpath(temp_path); + +Wrote file /tmp/oct_qWaxKh.m. ***** test - assert( isequal( subs(f, x, y), y^2 )) - assert( isequal( subs(f, y, sin(x)), x*sin(x) )) - assert( isequal( subs(f, x, 16), 16*y )) + % output to disk: also works with .m specified + if (exist ('OCTAVE_VERSION', 'builtin')) + temp_file = [tempname('', 'oct_') '.m']; + else + temp_file = [tempname() '.m']; + end + % allow loading function from temp_file + [temp_path, ans, ans] = fileparts(temp_file); + addpath(temp_path); + f = function_handle(2*x*y, 2^x, 'vars', {x y z}, 'file', temp_file); + assert( isa(f, 'function_handle')) + addpath(temp_path); % Matlab 2014a needs this? + [a,b] = f(10,20,30); + assert (isnumeric (a) && isnumeric (b)) + assert (a == 400) + assert (b == 1024) + if (exist ('OCTAVE_VERSION', 'builtin')) + assert (unlink(temp_file) == 0) + else + delete (temp_file) + end + % remove temp_path from load path + rmpath(temp_path); +Wrote file /tmp/oct_jT1Yew.m. ***** test - % multiple subs w/ cells - assert( isequal( subs(f, {x}, {t}), y*t )) - assert( isequal( subs(f, {x y}, {t t}), t*t )) - assert( isequal( subs(f, {x y}, {t 16}), 16*t )) - assert( isequal( subs(f, {x y}, {16 t}), 16*t )) - assert( isequal( subs(f, {x y}, {2 16}), 32 )) + % non-scalar outputs + H = [x y z]; + M = [x y; z 16]; + V = [x;y;z]; + h = function_handle(H, M, V); + [t1,t2,t3] = h(1,2,3); + assert(isequal(t1, [1 2 3])) + assert(isequal(t2, [1 2; 3 16])) + assert(isequal(t3, [1;2;3])) ***** test - % multiple subs w/ vectors - assert( isequal( subs(f, [x y], [t t]), t*t )) - assert( isequal( subs(f, [x y], [t 16]), 16*t )) - assert( isequal( subs(f, [x y], [2 16]), 32 )) + % non-scalar outputs in .m files + H = [x y z]; + M = [x y; z 16]; + V = [x;y;z]; + if (exist ('OCTAVE_VERSION', 'builtin')) + temp_file = tempname('', 'oct_'); + else + temp_file = tempname(); + end + % allow loading function from temp_file + [temp_path, ans, ans] = fileparts(temp_file); + addpath(temp_path); + h = function_handle(H, M, V, 'vars', {x y z}, 'file', temp_file); + assert( isa(h, 'function_handle')) + addpath(temp_path); % Matlab 2014a needs this? + [t1,t2,t3] = h(1,2,3); + assert(isequal(t1, [1 2 3])) + assert(isequal(t2, [1 2; 3 16])) + assert(isequal(t3, [1;2;3])) + if (exist ('OCTAVE_VERSION', 'builtin')) + assert (unlink([temp_file '.m']) == 0) + else + delete ([temp_file '.m']) + end + % remove temp_path from load path + rmpath(temp_path); +Wrote file /tmp/oct_0EroRB.m. ***** test - % anything you can think of - assert( isequal( subs(f, [x y], {t t}), t*t )) - assert( isequal( subs(f, {x y}, [t t]), t*t )) - assert( isequal( subs(f, {x; y}, [t; t]), t*t )) + % order of outputs is lexiographic + syms a A x y + f = y + 10*a + 100*x + 1000*A; + h = function_handle(f); + assert (h(1, 2, 3, 4) == 1000 + 20 + 300 + 4) ***** test - % sub in doubles gives sym (matches SMT 2013b) - % FIXME: but see - % http://www.mathworks.co.uk/help/symbolic/gradient.html - assert( isequal( subs(f, {x y}, {2 pi}), 2*sym(pi) )) - assert( ~isa(subs(f, {x y}, {2 pi}), 'double')) - assert( isa(subs(f, {x y}, {2 pi}), 'sym')) - assert( isa(subs(f, {x y}, {2 sym(pi)}), 'sym')) - assert( isa(subs(f, {x y}, {sym(2) sym(pi)}), 'sym')) -***** shared x,y,t,f,F - syms x y t - f = sin(x)*y; - F = [f; 2*f]; + % https://github.com/gnu-octave/symbolic/issues/854 + f = function_handle (x + 1i*sqrt (sym(3))); + assert (f (1), complex (1, sqrt (3)), -eps) +14 tests, 14 passed, 0 known failure, 0 skipped +[inst/@sym/sec.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sec.m +***** error sec (sym(1), 2) +***** assert (isequaln (sec (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); ***** test - % need the simultaneous=True flag in SymPy (matches SMT 2013b) - assert( isequal( subs(f, [x t], [t 6]), y*sin(t) )) - assert( isequal( subs(F, [x t], [t 6]), [y*sin(t); 2*y*sin(t)] )) + f1 = sec(x); + f2 = sec(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - % swap x and y (also needs simultaneous=True - assert( isequal( subs(f, [x y], [y x]), x*sin(y) )) + D = [d d; d d]; + A = [x x; x x]; + f1 = sec(A); + f2 = sec(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test - % but of course both x and y to t still works - assert( isequal( subs(f, [x y], [t t]), t*sin(t) )) -***** shared + % round trip + y = sym('y'); + A = sec (d); + f = sec (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/gammaln.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/gammaln.m +***** assert (isequal (gammaln (sym (3)), log (sym (2)))) +***** assert (isequal (gammaln (sym (10)), log (gamma (sym (10))))) ***** test - % Issue #10, subbing matrices in for scalars - syms y - a = sym([1 2; 3 4]); - f = sin(y); - g = subs(f, y, a); - assert (isequal (g, sin(a))) + % compare to Maple: evalf(lnGAMMA(Pi)); + maple = vpa ('0.827694592323437101529578558452359951153502', 40); + us = vpa (gammaln (sym(pi)), 40); + assert (abs(double(maple-us)) < 1e-39) ***** test - % Issue #10, subbing matrices in for scalars - syms y - a = sym([1 2]); - g = subs(sin(y), {y}, {a}); - assert (isequal (g, sin(a))) + % compare to Maple: evalf(lnGAMMA(3+2*I)); + maple = vpa ('-0.0316390593739611898037677296008797172022603', 40) + ... + vpa ('2.02219319750132712401643376238334982100512j', 40); + us = vpa (gammaln (sym(3) + 2i), 40); + assert (abs(double(maple-us)) < 1e-39) ***** test - % Issue #10, subbing matrices in for scalars - syms y - a = sym([1; 2]); - g = subs(sin(y), {y}, a); - assert (isequal (g, sin(a))) + % compare to Maple: evalf(lnGAMMA(-1.5)); + % notably, @double/gammaln has zero imag part + maple = vpa ('0.8600470153764810145109326816703567873271571', 40) - ... + vpa ('6.2831853071795864769252867665590057683943388j', 40); + us = vpa (gammaln (-sym(3)/2), 40); + assert (abs(double(maple-us)) < 1e-39) +***** assert (gammaln (pi), double (gammaln (sym (pi))), -3*eps) +***** assert (gammaln (100), double (gammaln (sym (100))), -3*eps) +***** assert (gammaln (1e-3), double (gammaln (1/sym (1e3))), -100*eps) ***** test - % Issue #10, subbing matrices in for scalars - syms y - a = [10 20 30]; - f = 2*y; - g = subs(f, y, a); - assert (isequal (g, 2*a)) - assert (isa (g, 'sym')) + % round trip + syms x + f = gammaln (x); + h = function_handle (f); + A = h (1.1); + B = gammaln (1.1); + assert (A, B) +9 tests, 9 passed, 0 known failure, 0 skipped +[inst/@sym/equationsToMatrix.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/equationsToMatrix.m ***** test - % Issue #10, sub matrices in for two scalars - syms x y - a = [10 20 30]; - f = x^2*y; - g = subs(f, {x y}, {a a+1}); - h = a.^2.*(a+1); - assert (isequal (g, h)) + syms x y z + [A, B] = equationsToMatrix ([x + y - z == 1, 3*x - 2*y + z == 3, 4*x - 2*y + z + 9 == 0], [x, y, z]); + a = sym ([1 1 -1; 3 -2 1; 4 -2 1]); + b = sym ([1; 3; -9]); + assert (isequal (A, a)) + assert (isequal (B, b)) ***** test - % Issue #10, sub matrices in for two scalars syms x y z - a = [10 20 30]; - f = x^2*y; - g = subs(f, {x y}, {a z}); - h = a.^2*z; - assert (isequal (g, h)) - g = subs(f, {x y}, {a 6}); - h = a.^2*6; - assert (isequal (g, h)) -***** error - syms x y - a = [10 20 30]; - f = x^2*y; - g = subs(f, {x y}, {[10 20 30] [10 20]}); + A = equationsToMatrix ([3*x + -3*y - 5*z == 9, 4*x - 7*y + -3*z == -1, 4*x - 9*y - 3*z + 2 == 0], [x, y, z]); + a = sym ([3 -3 -5; 4 -7 -3; 4 -9 -3]); + assert (isequal (A, a)) ***** test - % two inputs syms x y - assert (isequal (subs (2*x, 6), sym(12))) - assert (isequal (subs (2*x*y^2, 6), 12*y^2)) - assert (isequal (subs (2*y, 6), sym(12))) - assert (isequal (subs (sym(2), 6), sym(2))) + [A, B] = equationsToMatrix ([3*x + 9*y - 5 == 0, -8*x - 3*y == -2]); + a = sym ([3 9; -8 -3]); + b = sym ([5; -2]); + assert (isequal (A, a)) + assert (isequal (B, b)) ***** test - % only two inputs, vector - syms x - assert (isequal (subs (2*x, [3 5]), sym([6 10]))) + % override symvar order + syms x y + [A, B] = equationsToMatrix ([3*x + 9*y - 5 == 0, -8*x - 3*y == -2], [y x]); + a = sym ([9 3; -3 -8]); + b = sym ([5; -2]); + assert (isequal (A, a)) + assert (isequal (B, b)) ***** test - % SMT compat, subbing in vec/mat for nonexist x syms x y z - % you might think this would be y: - assert (~ isequal (subs (y, x, [1 2]), y)) - % but it gives two y's: - assert (isequal (subs (y, x, [1 2]), [y y])) - assert (isequal (subs (sym(42), [3 5]), sym([42 42]))) - assert (isequal (subs (sym(42), x, []), sym([]))) - assert (isequal (subs (y, {x y}, {[1 2; 3 4], 6}), sym([6 6; 6 6]))) - assert (isequal (subs (y, {x z}, {[1 2; 3 4], 6}), [y y; y y])) + [A, B] = equationsToMatrix ([x - 9*y + z == -5, -9*y*z == -5], [y, x]); + a = sym ([[-9 1]; -9*z 0]); + b = sym ([-5 - z; -5]); + assert (isequal (A, a)) + assert (isequal (B, b)) ***** test syms x y - assert (isequal (subs (sym(42), x, y), sym(42))) - assert (isequal (subs (sym(42), y), sym(42))) - assert (isequal (subs (sym(42)), sym(42))) -***** test - % empty lists - assert (isequal (subs (sym(42), {}, {}), sym(42))) - assert (isequal (subs (42, sym([]), sym([])), sym(42))) + [A, B] = equationsToMatrix (-6*x + 4*y == 5, 4*x - 4*y - 5, x, y); + a = sym ([-6 4; 4 -4]); + b = sym ([5; 5]); + assert (isequal (A, a)) + assert (isequal (B, b)) ***** test + % vertical list of equations syms x y - f = x*y; - x = 6; y = 7; - g = subs (f); - assert (isequal (g, sym (42))) - assert (isa (g, 'sym')) + [A, B] = equationsToMatrix ([-6*x + 4*y == 5; 4*x - 4*y - 5], [x y]); + a = sym ([-6 4; 4 -4]); + b = sym ([5; 5]); + assert (isequal (A, a)) + assert (isequal (B, b)) ***** test syms x y - f = x*y; - x = 6; - g = subs (f); - assert (isequal (g, 6*y)) -***** test + [A, B] = equationsToMatrix (5*x == 1, y, x - 6*y - 7, y); + a = sym ([0; 1; -6]); + b = sym ([1 - 5*x; 0; -x + 7]); + assert (isequal (A, a)) + assert (isequal (B, b)) +***** error syms x y - f = x*y; - xsave = x; - x = 6; - g = subs (f); - assert (isequal (g, 6*y)) - assert (isequal (f, xsave*y)) + [A, B] = equationsToMatrix (x^2 + y^2 == 1, x - y + 1, x, y); ***** test - syms a x y - f = a*x*y; - a = 6; - clear x - g = subs (f); + % single equation syms x - assert (isequal (g, 6*x*y)) -25 tests, 25 passed, 0 known failure, 0 skipped + [A, B] = equationsToMatrix (3*x == 2, x); + a = sym (3); + b = sym (2); + assert (isequal (A, a)) + assert (isequal (B, b)) +***** test + % single equation w/ symvar + syms x + [A, B] = equationsToMatrix (3*x == 2); + a = sym (3); + b = sym (2); + assert (isequal (A, a)) + assert (isequal (B, b)) +***** error + syms x + equationsToMatrix (3*x == 2, [x x]) +12 tests, 12 passed, 0 known failure, 0 skipped +[inst/@sym/cross.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cross.m +***** error cross (sym(1), 2, 3) +***** test + a = sym([1; 0; 0]); + b = sym([0; 1; 0]); + c = cross(a, b); + assert (isequal (c, sym([0; 0; 1]))) +***** test + syms x + a = sym([x; 0; 0]); + b = sym([0; 1; 0]); + c = cross(a, b); + assert (isequal (c, sym([0; 0; x]))) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/ezmesh.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ezmesh.m +***** error + syms u v t + ezmesh(u*v, 2*u*v, 3*v*t) +***** error + syms u v t + ezmesh(u*v, 2*u*v, u*v*t) +2 tests, 2 passed, 0 known failure, 0 skipped [inst/@sym/ctranspose.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ctranspose.m ***** test @@ -11179,362 +11712,267 @@ B = [conj(x); true; -sym(1i)]; assert (isequal ( A', B)) 9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/char.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/char.m -***** test - % issue #91: expose as string - a = sym(pi); - assert (strcmp (char (a), 'pi')) -***** shared x - x = sym('x'); -***** assert (strcmp (char (x), 'x')) -***** assert (strcmp (char (2*x), '2*x')) -***** assert (strcmp (char ([2*x x]), 'Matrix([[2*x, x]])')) -***** assert (strcmp (char ([2*x 2; 1 x]), 'Matrix([[2*x, 2], [1, x]])')) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/psi.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/psi.m -***** assert (isequal (psi (sym (1)), -eulergamma)) -***** assert (isequal (psi (1, sym (1)), sym (pi)^2/6)) -***** assert (isinf (psi (sym ('inf')))) -***** test - % compare to Maple: evalf(Psi(-101/100)); - maple = vpa ('100.3963127058453949545769053445198842332424', 40); - us = vpa (psi (sym (-101)/100), 40); - assert (abs(double(maple-us)) < 1e-39) -***** test - % compare to Maple: evalf(Psi(1, 3*I-2)); - maple = vpa ('-0.1651414829219882371561038184133243839778799', 40) - ... - vpa ('0.1960040752985823275302034466611711263617296j', 40); - us = vpa (psi (1, sym (-2) + sym(3i)), 40); - assert (abs(double(maple-us)) < 1e-39) -***** test - % should match @double/psi - if (exist ('psi','builtin')) - assert (psi (pi), double (psi (sym (pi))), -3*eps) - assert (psi (100), double (psi (sym (100))), -3*eps) - assert (psi (1e-3), double (psi (1/sym (1e3))), -3*eps) - if (exist ('OCTAVE_VERSION', 'builtin')) - % 2014a doesn't support negative or complex arguments - assert (psi (-1.5), double (psi (sym (-3)/2)), -3*eps) - assert (psi (-8.3), double (psi (sym (-83)/10)),-4*eps) - assert (psi (2i), double (psi (sym (2i))), -3*eps) - assert (psi (10i+3), double (psi (sym (10i)+3)), -3*eps) - end - end -***** test - % @double/psi loses accuracy near the poles: note higher rel tol - if (exist ('psi','builtin')) - if (exist ('OCTAVE_VERSION', 'builtin')) - assert (psi (-1.1), double (psi (sym (-11)/10)), -6*eps) - assert (psi (-1.01), double (psi (sym (-101)/100)), -50*eps) - end - end -***** test - if (exist ('psi','builtin')) - assert (psi (1, pi), double (psi (1, sym (pi))), -3*eps) - assert (psi (1, 100), double (psi (1, sym (100))), -3*eps) - assert (psi (1, 1e-4), double (psi (1, 1/sym (1e4))), -3*eps) - end -***** test - if (exist ('psi','builtin')) - assert (psi (2, pi), double (psi (2, sym (pi))), -3*eps) - assert (psi (2, 1000), double (psi (2, sym (1000))), -3*eps) - assert (psi (2, 1e-4), double (psi (2, 1/sym (1e4))), -3*eps) - end +[inst/@sym/expm.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/expm.m ***** test - % round trip - if (exist ('psi','builtin')) + % scalar syms x - f = psi (x); - h = function_handle (f); - A = h (1.1); - B = psi (1.1); - assert (A, B) - end -10 tests, 10 passed, 0 known failure, 0 skipped -[inst/@sym/symvar.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/symvar.m -***** error symvar (sym(1), 2, 3) -***** test - %% some empty cases - assert (isempty (symvar (sym(1)))); - assert (isempty (symvar (sym(1),1))); - assert (isempty (symvar (sym(1),0))); - assert (isempty (symvar (sym('x'),0))); -***** shared x,y,f - x=sym('x'); y=sym('y'); f=x^2+3*x*y-y^2; -***** assert (isequal (symvar (f), [x y])); -***** assert (isequal (symvar (f, 1), x)); -***** test - %% closest to x - syms x y a b c xx - alpha = sym('alpha'); - % https://www.mathworks.com/matlabcentral/newsreader/view_thread/237730 - assert( isequal (symvar (b*xx*exp(alpha) + c*sin(a*y), 2), [xx y])) - %% tests to match Matlab R2013b -***** shared x,y,z,a,b,c,X,Y,Z - syms x y z a b c X Y Z -***** test - %% X,Y,Z first if no 2nd argument - s = prod([x y z a b c X Y Z]); - assert (isequal( symvar (s), [X Y Z a b c x y z] )) -***** test - %% uppercase have *low* priority with argument? - s = prod([x y z a b c X Y Z]); - assert (isequal (symvar (s,4), [x, y, z, c] )) -***** test - %% closest to x - s = prod([y z a b c Y Z]); - assert (isequal( symvar (s,6), [ y, z, c, b, a, Y] )) - s = prod([a b c Y Z]); - assert (isequal( symvar (s,4), [ c, b, a, Y] )) + assert (isequal (expm(x), exp(x))) ***** test - %% upper case letters in correct order - s = X*Y*Z; - assert (isequal( symvar (s,3), [X Y Z] )) + % diagonal + A = [sym(1) 0; 0 sym(3)]; + B = [exp(sym(1)) 0; 0 exp(sym(3))]; + assert (isequal (expm(A), B)) ***** test - % diff. assumptions make diff. symbols - x1 = sym('x'); - x2 = sym('x', 'positive'); - f = x1*x2; - assert (length (symvar (f)) == 2) - z = symvar (f, 1); - assert (xor (isequal (z, x1), isequal (z, x2))) -10 tests, 10 passed, 0 known failure, 0 skipped -[inst/@sym/besselk.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/besselk.m + % diagonal w/ x + syms x positive + A = [sym(1) 0; 0 x+2]; + B = [exp(sym(1)) 0; 0 exp(x+2)]; + assert (isequal (expm(A), B)) ***** test - X = [1 2 3; 4 5 6]; - ns = [sym(0) 1 -2; sym(1)/2 -sym(3)/2 pi]; - n = double(ns); - A = double(besselk(ns, X)); - B = besselk(n, X); - assert (all (all (abs (A - B) < 2*eps*abs(A)))) + % non-diagonal + syms x positive + A = [sym(1) 2; 0 x+2]; + B = expm(A); + C = double(subs(B, x, 4)); + D = expm(double(subs(A, x, 4))); + assert (max (max (abs (C - D))) <= 1e-11) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/arg.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/arg.m ***** test - % roundtrip syms x - A = besselk(2, 10); - q = besselk(2, x); - h = function_handle(q); - B = h(10); - assert (abs (A - B) <= eps*abs(A)) -***** error besselk(sym('x')) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/cosint.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cosint.m -***** error cosint (sym(1), 2) -***** xtest - assert (isequaln (cosint (sym(nan)), sym(nan))) -!!!!! known failure -assert (isequaln (cosint (sym (nan)), sym (nan))) failed + assert (isequal (angle (x), arg (x))); +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@sym/asech.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/asech.m +***** error asech (sym(1), 2) +***** assert (isequaln (asech (sym(nan)), sym(nan))) ***** shared x, d - d = 1; - x = sym('1'); + d = 1/2; + x = sym('1/2'); ***** test - f1 = cosint(x); - f2 = 0.3374039229009681346626; + f1 = asech(x); + f2 = asech(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = cosint(A); - f2 = 0.3374039229009681346626; - f2 = [f2 f2; f2 f2]; + f1 = asech(A); + f2 = asech(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = cosint (d); - f = cosint (y); + A = asech (d); + f = asech (y); h = function_handle (f); B = h (d); assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/numel.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/numel.m ***** test - % rewrite - syms x - y1 = cosint (x); - y2 = rewrite (y1, 'Integral'); - d1 = diff (y1, x); - d2 = diff (y2, x); - assert (isequal (d1, simplify(d2))) - v1 = double (subs (d1, x, 2)); - v2 = double (subs (d2, x, 2)); - assert (v1, v2, -eps) -6 tests, 5 passed, 1 known failure, 0 skipped -[inst/@sym/symsum.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/symsum.m -***** error symsum (sym(1), 2, 3, 4, 5) + a = sym([1 2 3]); + assert(numel(a) == 3); ***** test - % finite sums - syms n - assert (isequal (symsum(n,n,1,10), 55)) - assert(isa(symsum(n,n,1,10), 'sym')) - assert (isequal (symsum(n,n,sym(1),sym(10)), 55)) - assert (isequal (symsum(n,n,sym(1),sym(10)), 55)) - assert (isequal (symsum(1/n,n,1,10), sym(7381)/2520)) + % 2D array + a = sym([1 2 3; 4 5 6]); + assert(numel(a) == 6); ***** test - % negative limits - syms n - assert (isequal (symsum(n,n,-3,3), sym(0))) - assert (isequal (symsum(n,n,-3,0), sym(-6))) - assert (isequal (symsum(n,n,-3,-1), sym(-6))) + % empty + a = sym([]); + assert(numel(a) == 0); +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/laplacian.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/laplacian.m +***** shared x,y,z + syms x y z ***** test - % one input - syms n - f = symsum (n); - g = n^2/2 - n/2; - assert (isequal (f, g)) - f = symsum (2*n); - g = n^2 - n; - assert (isequal (f, g)) + % 1D + f = x^2; + g = diff(f,x,x); + assert (isequal (laplacian(f), g)) + assert (isequal (laplacian(f,{x}), g)) + assert (isequal (laplacian(f,[x]), g)) + assert (isequal (laplacian(f,x), g)) ***** test - % constant input - f = symsum (sym(2)); + % const + f = sym(1); + g = sym(0); + assert (isequal (laplacian(f), g)) + assert (isequal (laplacian(f,x), g)) + f = sym('c'); + assert (isequal (laplacian(f,x), g)) +***** test + % double const + f = 1; + g = sym(0); + assert (isequal (laplacian(f,x), g)) +***** test + % 1D fcn in 2d/3d + f = sin(2*y); + g = -4*f; + assert (isequal (laplacian(f), g)) + assert (isequal (laplacian(f, {x,y}), g)) + assert (isequal (laplacian(f, {x,y,z}), g)) +***** test + % 2d fcn in 2d/3d + f = sin(exp(x)*y); + g = diff(f,x,x) + diff(f,y,y); + assert (isequal (laplacian(f), g)) + assert (isequal (laplacian(f, {x,y}), g)) +***** test + % 2d fcn in 2d/3d + f = sin(exp(x)*y+sinh(z)); + gr2 = gradient(f, {x,y}); + divgr2 = divergence(gr2, {x,y}); + l2 = laplacian(f,{x,y}); + gr3 = gradient(f, {x,y,z}); + divgr3 = divergence(gr3, {x,y,z}); + l3 = laplacian(f,{x,y,z}); + assert (isAlways (l2 == divgr2)) + assert (isAlways (l3 == divgr3)) +***** error laplacian(sym('x'), sym('x'), 42) +***** error laplacian([sym('x'), sym('x')]) +8 tests, 8 passed, 0 known failure, 0 skipped +[inst/@sym/eq.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/eq.m +***** test + % simple tests with scalar numbers + assert (logical (sym(1) == sym(1))) + assert (logical (sym(1) == 1)) + assert (~logical (sym(1) == 0)) + assert (isequal (sym(1) == sym(1), sym(true))) + assert (isequal (sym(1) == 1, sym(true))) + assert (isequal (sym(1) == 0, sym(false))) +***** test + % Type of the output is sym or logical? + % FIXME: in current version, they are sym + e = sym(1) == sym(1); + %assert (islogical (e)) + assert (isa (e, 'sym')) +***** test + % things involving a variable are usually not bool but sym. + % (SMT behaviour says always, FIXME: currently we differ.) syms x - g = 2*x; - assert (isequal (f, g)) + e = x == 0; + assert (~islogical (e)) + assert (isa (e, 'sym')) ***** test - % two inputs - syms n - f = symsum (2*n, n); - g = n^2 - n; - assert (isequal (f, g)) + % ... except of course via cancellation + syms x + e = x - x == 0; + assert (logical (e)) + assert (isequal (e, sym(true))) ***** test - % two inputs, second is range - syms n - f = symsum (n, [1 6]); - g = 21; - assert (isequal (f, g)) - f = symsum (n, [sym(1) 6]); - g = 21; - assert (isequal (f, g)) - f = symsum (2*n, [1 6]); - g = 2*21; - assert (isequal (f, g)) + % array == array + a = sym([1 2; 3 4]); + y = a == a; + assert (isequal( size(y), [2 2])) + assert (isequal (y, sym([true true; true true]))) + assert (all(all(y))) + y = a == 1; + assert (isequal( size(y), [2 2])) + assert (isequal (y, sym([true false; false false]))) + assert (any(any(y))) + y = a == 42; + assert (isequal( size(y), [2 2])) + assert (isequal (y, sym([false false; false false]))) ***** test - % three inputs, last is range - syms n - f = symsum (2*n, n, [1 4]); - g = sym(20); - assert (isequal (f, g)) - f = symsum (2*n, n, [sym(1) 4]); - g = sym(20); - assert (isequal (f, g)) - f = symsum (2, n, [sym(1) 4]); - g = sym(8); - assert (isequal (f, g)) + % more array == array + D = [0 1; 2 3]; + A = [sym(0) 1; sym(2) 3]; + DZ = D - D; + assert (isequal (logical(A == A), [true true; true true])) + assert (isequal (logical(A == D), [true true; true true])) + assert (isequal (logical(A - D == DZ), [true true; true true])) + assert (all (all ( A == A ))) + assert (all (all ( A == D ))) + assert (all (all ( A - D == DZ ))) ***** test - % three inputs, no range - syms n - f = symsum (2*n, 1, 4); - g = sym(20); - assert (isequal (f, g)) - f = symsum (5, sym(1), 3); - g = sym(15); - assert (isequal (f, g)) + % logical output, right shape, etc + t = true; f = false; + a = sym([0 1 2; 3 4 5]); + b = sym([0 1 1; 3 5 5]); + e = a == b; + eexp = sym(logical([1 1 0; 1 0 1])); + assert (isequal (e, eexp)) + a = sym([0 1 2]); + b = sym([0 1 1]); + e = a == b; + eexp = sym(logical([1 1 0])); + assert (isequal (e, eexp)) + e = a' == b'; + eexp = eexp.'; % is/was bug here with ' + assert (isequal (e, eexp)) ***** test - % ok to use double's for arguments in infinite series - syms n oo - assert(isequal(symsum(1/n^2,n,1,oo), sym(pi)^2/6)) - assert(isequal(symsum(1/n^2,n,1,inf), sym(pi)^2/6)) + % empty matrices compare to correct empty size + a = zeros (sym(3), 0); + assert (size (a == a), [3, 0]) + a = zeros (sym(0), 2); + assert (size (a == a), [0, 2]) +8 tests, 8 passed, 0 known failure, 0 skipped +[inst/@sym/lhs.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/lhs.m ***** test - % should be oo because 1 is real but seems to be - % zoo/oo depending on sympy version - syms n oo - zoo = sym('zoo'); - assert (isequal (symsum(1/n,n,1,oo), oo) || ... - isequal (symsum(1/n,n,1,oo), zoo)) -11 tests, 11 passed, 0 known failure, 0 skipped -[inst/@sym/ellipticCPi.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipticCPi.m -***** error ellipticCPi (sym (1)) -***** error ellipticCPi (sym (1), 2, 3) -***** assert (double (ellipticCPi (0, sym (1)/2)), 1.854074677, 10e-10) -***** assert (double (ellipticCPi (sym (6)/10, sym(71)/10)), 1.29469534336658, -20*eps) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/log10.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/log10.m -***** assert (isequal (log10 (sym (1000)), sym (3))) -***** assert (isequal (log10 (sym ([10 100])), sym ([1 2]))) + syms x y + f = x + 1 == 2*y; + assert (isequal (lhs(f), x + 1)) + assert (isequal (rhs(f), 2*y)) ***** test - % round-trip + syms x y + f = x + 1 < 2*y; + assert (isequal (lhs(f), x + 1)) + assert (isequal (rhs(f), 2*y)) +***** test + syms x y + f = x + 1 >= 2*y; + assert (isequal (lhs(f), x + 1)) + assert (isequal (rhs(f), 2*y)) +***** test + syms x y + A = [x == y 2*x < 2*y; 3*x > 3*y 4*x <= 4*y; 5*x >= 5*y x < 0]; + L = [x 2*x; 3*x 4*x; 5*x x]; + R = [y 2*y; 3*y 4*y; 5*y 0]; + assert (isequal( lhs(A), L)) + assert (isequal( rhs(A), R)) +***** error syms x - f = log10 (x); - h = function_handle (f); - A = h (1.1); - B = log10 (1.1); - assert (A, B, -eps) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/coth.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/coth.m -***** error coth (sym(1), 2) -***** assert (isequaln (coth (sym(nan)), sym(nan))) + lhs(x) +***** error + lhs(sym(true)) +***** error + syms x + A = [1 + x == 2*x sym(6)]; + lhs(A) +7 tests, 7 passed, 0 known failure, 0 skipped +[inst/@sym/asec.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/asec.m +***** error asec (sym(1), 2) +***** assert (isequaln (asec (sym(nan)), sym(nan))) ***** shared x, d - d = 1; - x = sym('1'); + d = 2; + x = sym('2'); ***** test - f1 = coth(x); - f2 = coth(d); + f1 = asec(x); + f2 = asec(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = coth(A); - f2 = coth(D); + f1 = asec(A); + f2 = asec(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = coth (d); - f = coth (y); + A = asec (d); + f = asec (y); h = function_handle (f); B = h (d); assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/formula.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/formula.m -***** test - syms x - assert (isequal (formula(x), x)) - assert (isequal (formula(2*x), 2*x)) -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@sym/and.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/and.m -***** shared t, f - t = sym(true); - f = sym(false); -***** test - % simple - assert (isequal (t & f, f)) - assert (isequal (t & t, t)) -***** test - % mix with nonsym - assert (isequal (t & false, f)) - assert (isequal (t & true, t)) - assert (isequal (t & 0, f)) - assert (isequal (t & 1, t)) - assert (isa (t & false, 'sym')) - assert (isa (t & 1, 'sym')) -***** test - % array - w = [t t f f]; - z = [t f t f]; - assert (isequal (w & z, [t f f f])) -***** test - % number - assert (isequal( sym(1) & t, t)) - assert (isequal( sym(0) & t, f)) -***** test - % output is sym even for scalar t/f - assert (isa (t & f, 'sym')) -***** test - % eqns, exclusive - syms x - e = (x == 3) & (x^2 == 9); - assert (isequal (subs(e, x, [-3 0 3]), [f f t])) -***** error and (sym('x'), 2, 3) -7 tests, 7 passed, 0 known failure, 0 skipped [inst/@sym/expint.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/expint.m ***** error expint (sym(1), 2, 3) @@ -11576,318 +12014,390 @@ f = expint (n, x); h = function_handle (f); 8 tests, 8 passed, 0 known failure, 0 skipped -[inst/@sym/sech.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sech.m -***** error sech (sym(1), 2) -***** assert (isequaln (sech (sym(nan)), sym(nan))) +[inst/@sym/divisors.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/divisors.m +***** test + assert( isequal( divisors(sym(150)), divisors(sym(-150)) )) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@sym/symprod.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/symprod.m +***** error symprod (sym(1), 2, 3, 4, 5) +***** test + % simple + syms n + assert (isequal (symprod(n, n, 1, 10), factorial(sym(10)))) + assert (isequal (symprod(n, n, sym(1), sym(10)), factorial(10))) +***** test + % one input + syms n + f = symprod (n); + g = factorial (n); + assert (isequal (f, g)) + f = symprod (2*n); + g = 2^n * factorial (n); + assert (isequal (f, g)) +***** test + % constant input + f = symprod (sym(2)); + syms x + g = 2^x; + assert (isequal (f, g)) +***** test + % two inputs + syms n + f = symprod (2*n, n); + g = 2^n * factorial (n); + assert (isequal (f, g)) +***** test + % two inputs, second is range + syms n + f = symprod (n, [1 6]); + g = 720; + assert (isequal (f, g)) + f = symprod (n, [sym(1) 6]); + g = 720; + assert (isequal (f, g)) + f = symprod (2*n, [1 6]); + g = sym(2)^6*720; + assert (isequal (f, g)) +***** test + % three inputs, last is range + syms n + f = symprod (2*n, n, [1 4]); + g = sym(384); + assert (isequal (f, g)) + f = symprod (2*n, n, [sym(1) 4]); + g = sym(384); + assert (isequal (f, g)) + f = symprod (2, n, [sym(1) 4]); + g = sym(16); + assert (isequal (f, g)) +***** test + % three inputs, no range + syms n + f = symprod (2*n, 1, 4); + g = sym(384); + assert (isequal (f, g)) + f = symprod (5, sym(1), 3); + g = sym(125); + assert (isequal (f, g)) +***** test + % infinite product + syms a n oo + zoo = sym('zoo'); + assert (isequal (symprod(a, n, 1, oo), a^oo)) + assert (isequal (symprod(a, n, 1, inf), a^oo)) +9 tests, 9 passed, 0 known failure, 0 skipped +[inst/@sym/erfinv.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/erfinv.m +***** error erfinv (sym(1), 2) +***** assert (isequaln (erfinv (sym(nan)), sym(nan))) ***** shared x, d - d = 1; - x = sym('1'); + d = 1/2; + x = sym('1/2'); ***** test - f1 = sech(x); - f2 = sech(d); + f1 = erfinv(x); + f2 = erfinv(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = sech(A); - f2 = sech(D); + f1 = erfinv(A); + f2 = erfinv(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = sech (d); - f = sech (y); + A = erfinv (d); + f = erfinv (y); h = function_handle (f); B = h (d); assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/norm.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/norm.m -***** assert (isequal (norm(sym(-6)), 6)) -***** test - % 2-norm default - A = [1 2; 3 4]; - n1 = norm (sym (A)); - assert (isequal (n1, sqrt (sqrt (sym(221)) + 15))) - assert (norm (A), double (n1), -eps) -***** test - syms x y real - assert (isequal (norm([x 1; 3 y], 'fro'), sqrt(x^2 + y^2 + 10))) +[inst/@sym/besseli.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/besseli.m ***** test - syms x real - assert (isequal (norm([x 1], 2), sqrt(x^2 + 1))) + X = [1 2 3; 4 5 6]; + ns = [sym(0) 1 -2; sym(1)/2 -sym(3)/2 pi]; + n = double(ns); + A = double(besseli(ns, X)); + B = besseli(n, X); + assert (all (all (abs (A - B) < 100*eps*abs(A)))) ***** test - % test sym vs double ord + % roundtrip syms x - assert (isequal (norm([x 2 1], 1), abs(x) + 3)) - assert (isequal (norm([x 2 1], sym(1)), abs(x) + 3)) - assert (isequal (norm([sym(-3) 2 1], inf), sym(3))) - assert (isequal (norm([sym(-3) 2 1], sym(inf)), sym(3))) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/gt.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/gt.m + A = besseli(2, 10); + q = besseli(2, x); + h = function_handle(q); + B = h(10); + assert (abs (A - B) <= eps*abs(A)) +***** error besseli(sym('x')) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/cart2pol.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cart2pol.m ***** test - % simple - x = sym(1); y = sym(1); e = x > y; - assert (~logical (e)) - x = sym(1); y = sym(2); e = x > y; - assert (~logical (e)) + % multiple non-scalar inputs + x = sym ('x', [2 2]); + assume (x, 'real'); + y = sym ('y', [2 2]); + assume (y, 'real'); + [theta, r] = cart2pol (x, y); + assert (isequal (r, sqrt (x.^2 + y.^2))); + assert (isequal (tan (theta), y ./ x)); + % mixing scalar inputs with non-scalar inputs + syms z real + [theta_2, r_2, z_2] = cart2pol (x, y, z); + assert (isequal (r_2, sqrt (x.^2 + y.^2))); + assert (isequal (tan (theta_2), y ./ x)); + assert (isequal (z_2, z * ones (2, 2))); ***** test - % array -- array - syms x - a = sym([1 3 3 2*x]); - b = sym([2 x 3 10]); - e = a > b; - assert (isa (e, 'sym')) - assert (~logical (e(1))) - assert (isa (e(2), 'sym')) - assert (isequal (e(2), 3 > x)) - assert (~logical (e(3))) - assert (isa (e(4), 'sym')) - assert (isequal (e(4), 2*x > 10)) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/exp.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/exp.m -***** error exp (sym(1), 2) -***** assert (isequaln (exp (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); + % column vector with 2 entries + syms x y real + [theta, r] = cart2pol ([x; y]); + assert (isequal (r, sqrt (x.^2 + y.^2))); + assert (isequal (tan (theta), y ./ x)); + % column vector with 3 entries + syms z real + [theta_2, r_2, z_2] = cart2pol ([x; y; z]); + assert (isequal (r_2, sqrt (x.^2 + y.^2))); + assert (isequal (tan (theta_2), y ./ x)); + assert (isequal (z_2, z)); ***** test - f1 = exp(x); - f2 = exp(d); - assert( abs(double(f1) - f2) < 1e-15 ) + % matrix with 2 columns + syms x y u v real + C = [x y; u v]; + [theta, r] = cart2pol (C); + assert (isequal (r, [sqrt(x.^2+y.^2); sqrt(u.^2+v.^2)])); + assert (isequal (tan (theta), [y/x; v/u])); + % matrix with 3 columns + syms z w real + C_2 = [x y z; u v w]; + [theta_2, r_2, z_2] = cart2pol (C_2); + assert (isequal (r, [sqrt(x.^2+y.^2); sqrt(u.^2+v.^2)])); + assert (isequal (tan (theta), [y/x; v/u])); + assert (isequal (z_2, [z; w])); +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/zeta.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/zeta.m +***** error zeta (sym(1), 2, 3) +***** assert (isequaln (zeta (sym(nan)), sym(nan))) ***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = exp(A); - f2 = exp(D); + f1 = zeta (sym(2)); + f2 = pi^2/6; + assert (double (f1), f2, -1e-15) +***** test + A = sym([0 2; 4 6]); + f1 = zeta (A); + f2 = [-1/2 pi^2/6; pi^4/90 pi^6/945]; assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = exp (d); - f = exp (y); + f = zeta (y); h = function_handle (f); - B = h (d); + A = zeta (2); + B = h (2); assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/factorial.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/factorial.m -***** error factorial (sym(1), 2) -***** xtest - assert (isequaln (factorial (sym(nan)), sym(nan))) -!!!!! known failure -assert (isequaln (factorial (sym (nan)), sym (nan))) failed +***** test + syms x + assert (isequal (zeta (0, x), zeta(x))) +***** test + % ensure its the nth deriv wrt x, not the n deriv + syms x n + F = zeta (n, x); + F = subs(F, n, 3); + assert (isequal (F, diff (zeta (x), x, x, x))) +7 tests, 7 passed, 0 known failure, 0 skipped +[inst/@sym/nnz.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/nnz.m +***** assert (nnz (sym ([1])) == 1) +***** assert (nnz (sym ([0])) == 0) +***** assert (nnz (sym ([])) == 0) +***** assert (nnz (sym ([1 0; 0 3])) == 2) +***** test + syms x + assert (nnz ([x 0]) == 1) +***** assert (nnz (sym (true)) == 1) +***** assert (nnz (sym (false)) == 0) +***** assert (nnz (sym (inf)) == 1) +***** assert (nnz (sym (nan)) == 1) +9 tests, 9 passed, 0 known failure, 0 skipped +[inst/@sym/atanh.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/atanh.m +***** error atanh (sym(1), 2) +***** assert (isequaln (atanh (sym(nan)), sym(nan))) ***** shared x, d - d = 1; - x = sym('1'); + d = 1/2; + x = sym('1/2'); ***** test - f1 = factorial(x); - f2 = factorial(d); + f1 = atanh(x); + f2 = atanh(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = factorial(A); - f2 = factorial(D); + f1 = atanh(A); + f2 = atanh(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = factorial (d); - f = factorial (y); + A = atanh (d); + f = atanh (y); h = function_handle (f); B = h (d); assert (A, B, -eps) -5 tests, 4 passed, 1 known failure, 0 skipped -[inst/@sym/numden.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/numden.m -***** error numden (sym(1), 2) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/qr.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/qr.m +***** error qr (sym(1), 2, 3) +***** error [Q, R, P] = qr (sym(1)) +***** error qr (sym(1), 1) ***** test - syms x - [n, d] = numden (1/x); - assert (isequal (n, sym(1)) && isequal (d, x)) + % scalar + [q, r] = qr(sym(6)); + assert (isequal (q, sym(1))) + assert (isequal (r, sym(6))) ***** test - syms x y - n1 = [sym(1); x]; - d1 = [x; y]; - [n, d] = numden (n1 ./ d1); - assert (isequal (n, n1) && isequal (d, d1)) + syms x positive + [q, r] = qr(x); + assert (isequal (q*r, x)) + assert (isequal (q, sym(1))) + assert (isequal (r, x)) ***** test - [n, d] = numden (sym(2)); - assert (isequal (n, 2)); - assert (isequal (d, 1)); + % trickier if x could be zero, fails on 1.8 <= SymPy <= 1.10.1 + syms x + [q, r] = qr(x); + if (pycall_sympy__ ('return Version(spver) > Version("1.10.1")')) + assert (isequal (q*r, x)) + end ***** test - syms x y - [n, d] = numden ((x + pi)/(y + 6)); - assert (isequal (n, x + pi)); - assert (isequal (d, y + 6)); + A = [1 2; 3 4]; + B = sym(A); + [Q, R] = qr(B); + assert (isequal (Q*R, B)) + assert (isequal (R(2,1), sym(0))) + assert (isequal (Q(:,1)'*Q(:,2), sym(0))) + %[QA, RA] = qr(A) + %assert ( max(max(double(Q)-QA)) <= 10*eps) + %assert ( max(max(double(Q)-QA)) <= 10*eps) ***** test - syms x y - [n, d] = numden ((x^2 + y^2)/(x*y)); - assert (isequal (n, x^2 + y^2)); - assert (isequal (d, x*y)); -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@sym/tand.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/tand.m -***** error tand (sym(1), 2) -***** assert (isequaln (tand (sym(nan)), sym(nan))) + % non square: tall skinny + A = sym([1 2; 3 4; 5 6]); + [Q, R] = qr (A, 0); + assert (size (Q), [3 2]) + assert (size (R), [2 2]) + assert (isequal (Q*R, A)) ***** test - f1 = tand (sym(1)); - f2 = tand (1); - assert (double (f1), f2, -eps) + % non square: short fat + A = sym([1 2 3; 4 5 6]); + [Q, R] = qr (A); + assert (isequal (Q*R, A)) ***** test - D = [10 30; 110 -45]; - A = sym(D); - f1 = tand (A); - f2 = tand (D); - assert (double (f1), f2, -eps) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/sinc.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sinc.m -***** error sinc (sym(1), 2) -***** assert (isequaln (sinc (sym(nan)), sym(nan))) -***** assert (isequal (sinc (sym(0)), sym(1))) -***** assert (isequal (sinc (sym(1)), sym(0))) -***** assert (isequal (sinc (-sym(1)), sym(0))) -***** assert (double (sinc (sym(pi))), sinc (pi), -10*eps) + % non square: short fat, rank deficient + A = sym([1 2 3; 2 4 6]); + [Q, R] = qr (A); + assert (isequal (Q*R, A)) + A = sym([1 2 3; 2 4 6; 0 0 0]); + [Q, R] = qr (A); + assert (isequal (Q*R, A)) ***** test - A = [-sym(1)/2 sym(1)/2 pi; -sym(7)/2 sym(71)/2 sym(101)/3]; - D = double (A); - assert (sinc (D), double (sinc (A)), -200*eps) + % rank deficient + A = sym([1 2 3; 2 4 6; 0 0 0]); + [Q, R] = qr (A); + assert (isequal (Q*R, A)) + A = sym([1 2 3; 2 5 6; 0 0 0]); + [Q, R] = qr (A); + assert (isequal (Q*R, A)) ***** test - A = [sym(51)/2 sym(1001)/3 sym(10001)/3 sym(100001)/3]; - D = double (A); - assert (sinc (D), double (sinc (A)), 1e-10) + % single return value R not Q + assert (isequal (qr (sym(4)), sym(4))) +12 tests, 12 passed, 0 known failure, 0 skipped +[inst/@sym/fortran.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/fortran.m +***** shared x,y,z + syms x y z ***** test - % round trip - syms x - A = sinc (1); - f = sinc (x); - h = function_handle (f); - B = h (1); - assert (A, B, -eps) + % basic test + f = x*sin(y) + abs(z); + source = fortran(f); + expected = ' x*sin(y) + abs(z)'; + s1 = strrep (expected, 'abs', 'Abs'); + assert (strcmp (source, expected) || strcmp (source, s1)) ***** test - % round trip - syms x - f = sinc (x); - h = function_handle (f); - A = sinc (1.5); - B = h (1.5); - assert (A, B, -eps) + % output test + f = x*sin(y) + abs(z); + [F,H] = fortran(f, 'file', '', 'show_header', false); + expected_h_code = sprintf('\ninterface\nREAL*8 function myfun(x, y, z)\nimplicit none\nREAL*8, intent(in) :: x\nREAL*8, intent(in) :: y\nREAL*8, intent(in) :: z\nend function\nend interface\n\n'); + expected_f_code = sprintf('\nREAL*8 function myfun(x, y, z)\nimplicit none\nREAL*8, intent(in) :: x\nREAL*8, intent(in) :: y\nREAL*8, intent(in) :: z\n\nmyfun = x*sin(y) + abs(z)\n\nend function\n'); + assert(strcmp(F.name, 'file.f90')) + assert(strcmp(H.name, 'file.h')) + %disp(expected_f_code); disp(F.code) + s1 = strrep (expected_f_code, 'abs', 'Abs'); + s2 = strrep (expected_f_code, sprintf ('\n'), sprintf ('\r\n')); + s3 = strrep (s2, 'abs', 'Abs'); + s4 = strrep (expected_h_code, sprintf ('\n'), sprintf ('\r\n')); + assert (strcmp (F.code, expected_f_code) || strcmp (F.code, s1) || strcmp (F.code, s2) || strcmp (F.code, s3)) + assert (strcmp (H.code, expected_h_code) || strcmp (H.code, s4)) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/besselyn.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/besselyn.m ***** test + % roundtrip syms x - h = function_handle (sinc (x)); - A = double (sinc (sym (12)/10)); - B = h (1.2); - C = sinc (1.2); - assert (A, B, -eps) - assert (A, C, -eps) -11 tests, 11 passed, 0 known failure, 0 skipped -[inst/@sym/isinf.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isinf.m -***** shared x,zoo,oo,snan - oo = sym(inf); - zoo = sym('zoo'); - x = sym('x'); - snan = sym(nan); -***** test - % various ops that give inf and nan - assert (isinf(oo)) - assert (isinf(zoo)) - assert (isinf(oo+oo)) - assert (~isinf(oo+zoo)) - assert (~isinf(0*oo)) - assert (~isinf(0*zoo)) - assert (~isinf(snan)) - assert (~isinf(oo-oo)) - assert (~isinf(oo-zoo)) -***** test - % arrays - assert (isequal( isinf([oo zoo]), [1 1] )) - assert (isequal( isinf([oo 1]), [1 0] )) - assert (isequal( isinf([10 zoo]), [0 1] )) - assert (isequal( isinf([x oo x]), [0 1 0] )) + A = double(besselyn(sym(2), sym(10))); + q = besselyn(sym(2), x); + h = function_handle(q); + B = h(10); + assert (abs (A - B) <= eps) +***** error yn(sym('x')) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/display.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/display.m ***** test - % Must not contain string 'symbol'; these all should make an - % actual infinity. Actually a ctor test, not isinf. - % IIRC, SMT in Matlab 2013b fails. - oo = sym(inf); - assert (isempty (strfind (sympy (oo), 'Symbol'))) - oo = sym(-inf); - assert (isempty (strfind (sympy (oo), 'Symbol'))) - oo = sym('inf'); - assert (isempty (strfind (sympy (oo), 'Symbol'))) - oo = sym('-inf'); - assert (isempty (strfind (sympy (oo), 'Symbol'))) - oo = sym('Inf'); - assert (isempty (strfind (sympy (oo), 'Symbol'))) + assert(true) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@sym/cot.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cot.m +***** error cot (sym(1), 2) +***** assert (isequaln (cot (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); ***** test - % ops with infinity shouldn't collapse - syms x oo zoo - y = x + oo; - assert (~isempty (strfind (lower (sympy (y)), 'add') )) - y = x - oo; - assert (~isempty (strfind (lower (sympy (y)), 'add') )) - y = x - zoo; - assert (~isempty (strfind (lower (sympy (y)), 'add') )) - y = x*oo; - assert (~isempty (strfind (lower (sympy (y)), 'mul') )) + f1 = cot(x); + f2 = cot(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - % ops with infinity are not necessarily infinite - syms x oo zoo - y = x + oo; - assert(~isinf(y)) % SMT 2014a says "true", I disagree - y = x - zoo; - assert(~isinf(y)) - y = x*oo; - assert(~isinf(y)) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/ellipticCE.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipticCE.m -***** error ellipticCE (sym (1), 2) -***** assert (isequal (ellipticCE (sym (0)), sym (1))) -***** assert (isequal (ellipticCE (sym (1)), sym (pi)/2)) -***** assert (double (ellipticCE (sym (pi)/4)), 1.482786927, 10e-10) -***** assert (double (ellipticCE (sym (pi)/2)), 1.775344699, 10e-10) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/chebyshevU.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/chebyshevU.m -***** error chebyshevU (sym(1)) -***** error chebyshevU (sym(1), 2, 3) -***** assert (isequaln (chebyshevU (2, sym(nan)), sym(nan))) -***** shared x - syms x -***** assert(isequal(chebyshevU(0, x), sym(1))) -***** assert(isequal(chebyshevU(1, x), 2*x)) -***** assert(isequal(chebyshevU(2, x), 4*x*x - 1)) -***** assert(isequal(chebyshevU([0 1 2], x), [sym(1) 2*x (4*x*x-1)])) + D = [d d; d d]; + A = [x x; x x]; + f1 = cot(A); + f2 = cot(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip - syms n z - f = chebyshevU (n, z); - h = function_handle (f, 'vars', [n z]); - A = h (1.1, 2.2); - B = chebyshevU (1.1, 2.2); - assert (A, B) -8 tests, 8 passed, 0 known failure, 0 skipped -[inst/@sym/dilog.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/dilog.m -***** assert (isequal (dilog (sym(1)), sym(0))) -***** assert (isequal (dilog (sym(0)), sym(pi)^2/6)) -***** assert (isequal (dilog (sym(2)), -sym(pi)^2/12)) -***** assert (double(dilog(sym(-1))), pi^2/4 - pi*1i*log(2), eps) -***** test - % round-trip - syms x - f = dilog (x); + y = sym('y'); + A = cot (d); + f = cot (y); h = function_handle (f); - A = h (1.1); - B = dilog (1.1); + B = h (d); assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/isprime.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isprime.m +***** assert (isprime (sym(5))) +***** assert (~isprime (sym(4))) +***** assert (~isprime (sym(0))) +***** assert (~isprime (sym(1))) +***** test + a = [5 7 6; 1 2 337]; + assert (isequal (isprime (a), [true true false; false true true])) +***** assert (~isprime(sym(-4))) +***** assert (~isprime(sym(4i))) +***** assert (~isprime(sym(3)/5)) +***** error + isprime(sym('x')); +9 tests, 9 passed, 0 known failure, 0 skipped [inst/@sym/assume.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/assume.m ***** test @@ -11995,500 +12505,640 @@ assert (strcmp (assumptions (c), 'c: real')) assert (strcmp (assumptions (d), 'd: real')) 16 tests, 16 passed, 0 known failure, 0 skipped -[inst/@sym/limit.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/limit.m -***** error limit (sym(1), 2, 3, 4, 5) -***** shared x, oo - syms x - oo = sym(inf); -***** assert (isa (limit(x, x, pi), 'sym')) -***** assert (isequal (limit(x, x, pi), sym(pi))) -***** assert (isequal (limit(sin(x)/x, x, 0), 1)) +[inst/@sym/sind.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sind.m +***** error sind (sym(1), 2) +***** assert (isequaln (sind (sym(nan)), sym(nan))) ***** test - % left/right-hand limit - assert (isequal (limit(1/x, x, 0, 'right'), oo)) - assert (isequal (limit(1/x, x, 0), oo)) - assert (isequal (limit(1/x, x, 0, 'left'), -oo)) - assert (isequal (limit(1/x, x, oo), 0)) - assert (isequal (limit(sign(x), x, 0, 'left'), -1)) - assert (isequal (limit(sign(x), x, 0, 'right'), 1)) - assert (isequal (limit(sign(x), x, 0, '-'), -1)) - assert (isequal (limit(sign(x), x, 0, '+'), 1)) + f1 = sind (sym(1)); + f2 = sind (1); + assert (double (f1), f2, -eps) ***** test - % matrix - syms y - A = [x 1/x x*y]; - B = sym([3 sym(1)/3 3*y]); - assert (isequal (limit(A, x, 3), B)) + D = [10 30; 110 -45]; + A = sym(D); + f1 = sind (A); + f2 = sind (D); + assert (double (f1), f2, -eps) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/prod.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/prod.m +***** error prod (sym(1), 2, 3) +***** error prod (sym(1), 42) +***** shared x,y,z + syms x y z +***** assert (isequal (prod (x), x)) +***** assert (isequal (prod ([x y z]), x*y*z)) +***** assert (isequal (prod ([x; y; z]), x*y*z)) +***** assert (isequal (prod ([x y z], 1), [x y z])) +***** assert (isequal (prod ([x y z], 2), x*y*z)) +***** shared a,b + b = [1 2; 3 4]; a = sym(b); +***** assert (isequal (prod(a), prod(b))) +***** assert (isequal (prod(a,1), prod(b,1))) +***** assert (isequal (prod(a,2), prod(b,2))) ***** test - % omitting arguments - syms a - assert (isequal (limit(a), 0)) - assert (isequal (limit(a*x+a+2), a+2)) - assert (isequal (limit(a*x+a+2, 6), 7*a+2)) + % weird inputs + a = prod('xx', sym(1)); + assert (isequal (a, sym('xx'))) +11 tests, 11 passed, 0 known failure, 0 skipped +[inst/@sym/triu.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/triu.m ***** test - % constants - assert (isequal (limit(sym(6)), 6)) - assert (isequal (limit(sym(6), 7), 6)) - assert (isequal (limit([sym(6) sym(2)], 7), [6 2])) + % scalar + syms x + assert (isequal (triu(x), x)) + assert (isequal (triu(x,0), x)) + assert (isequal (triu(x,1), 0)) + assert (isequal (triu(x,-1), 0)) ***** test - % double constant, with sym limit - a = limit (6, sym(0)); - assert (isa (a, 'sym')) - assert (isequal (a, sym(6))) -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/hilb.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/hilb.m + % with symbols + syms x + A = [x 2*x; 3*x 4*x]; + assert (isequal (triu(A), [x 2*x; 0 4*x])) ***** test - A = hilb (sym(3)); - B = [sym(1) sym(1)/2 sym(1)/3; sym(1)/2 sym(1)/3 sym(1)/4; sym(1)/3 sym(1)/4 sym(1)/5]; - assert (isequal (A, B)) -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@sym/isequaln.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isequaln.m + % diagonal shifts + B = round(10*rand(3,4)); + A = sym(B); + assert (isequal (triu(A), triu(B))) + assert (isequal (triu(A,0), triu(B,0))) + assert (isequal (triu(A,1), triu(B,1))) + assert (isequal (triu(A,-1), triu(B,-1))) ***** test - a = sym([1 2]); - b = a; - assert (isequaln (a, b)) - b(1) = 42; - assert (~isequaln (a, b)) + % double array pass through + B = round(10*rand(3,4)); + assert (isequal (triu(B,sym(1)), triu(B,1))) + assert (isa (triu(B,sym(1)), 'double')) ***** test - a = sym([1 2; 3 4]); - b = a; - assert (isequaln (a, b)) - b(1) = 42; - assert (~isequaln (a, b)) + % immutable test + A = sym('ImmutableDenseMatrix([[Integer(1), Integer(2)], [Integer(3), Integer(4)]])'); + assert (isequal (triu (A), sym ([1 2; 0 4]))) + assert (isequal (tril (A), sym ([1 0; 3 4]))) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/union.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/union.m ***** test - a = sym([nan; 2]); - b = a; - assert (isequaln (a, b)) + A = sym([1 2 3]); + B = sym([1 2 4]); + C = union(A, B); + D = sym([1 2 3 4]); + assert (isequal (C, D)) ***** test - a = sym([nan 2; 3 4]); - b = a; - assert (isequaln (a, b)) + % one nonsym + A = sym([1 2 3]); + B = [1 2 4]; + C = union(A, B); + D = sym([1 2 3 4]); + assert (isequal (C, D)) ***** test - % more than two arrays - a = sym([nan 2 3]); - b = a; - c = a; - assert (isequaln (a, b, c)) - c(1) = 42; - assert (~isequaln (a, b, c)) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/isAlways.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isAlways.m + % empty + A = sym([1 2 3]); + C = union(A, A); + assert (isequal(C, A)) ***** test - % basics - assert(isAlways(true)) - assert(isAlways(1==1)) - assert(isAlways(sym(1)==sym(1))) - assert(isAlways(sym(1)==1)) + % empty input + A = sym([1 2]); + C = union(A, []); + assert (isequal (C, sym([1 2]))) ***** test - % numbers to logic? - assert (isAlways(sym(1))) - assert (isAlways(sym(-1))) - assert (~isAlways(sym(0))) -***** shared x + % scalar syms x + assert (isequal (union([x 1], x), [1 x])) + assert (isequal (union(x, x), x)) ***** test - % in this case it is boolean - expr = x - x == 0; - assert (logical(expr)) - assert (isAlways(expr)) - % and both are logical type - assert (islogical(logical(expr))) - assert (islogical(isAlways(expr))) + A = interval(sym(1), 3); + B = interval(sym(2), 5); + C = union(A, B); + assert( isequal( C, interval(sym(1), 5))) +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@sym/setdiff.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/setdiff.m ***** test - % structurally same and mathematically true - % (here expr should be sym, non-boolean) - expr = x == x; - assert (logical(expr)) - assert (isAlways(expr)) - %assert (~islogical(expr)) % FIXME: Issue #56 - %assert (isa(expr, 'sym)) + A = sym([1 2 3]); + B = sym([1 2 4]); + C = setdiff(A, B); + D = sym([3]); + assert (isequal (C, D)) ***** test - % structurally same and mathematically true - % (here expr should be sym, non-boolean) - expr = 1 + x == x + 1; - assert (logical(expr)) - assert (isAlways(expr)) + % one nonsym + A = sym([1 2 3]); + B = [1 2 4]; + C = setdiff(A, B); + D = sym([3]); + assert (isequal (C, D)) ***** test - % non-zero numbers are true - assert (isAlways(sym(1))) - assert (isAlways(sym(-10))) - assert (~isAlways(sym(0))) -***** shared x, y - syms x y + % empty + A = sym([1 2 3]); + C = setdiff(A, A); + assert (isempty (C)) ***** test - % structurally same and mathematically true - % (here expr should be sym, non-boolean) - expr = x*(1+y) == x*(y+1); - assert (logical(expr)) - assert (isAlways(expr)) - assert (islogical(isAlways(expr))) + % empty input + A = sym([1 2]); + C = setdiff(A, []); + assert (isequal (C, A) || isequal (C, sym([2 1]))) ***** test - % Now for some differences - % simplest example from SymPy FAQ - expr = x*(1+y) == x+x*y; - assert (~logical(expr)) - assert (isAlways(expr)) + % scalar + syms x + assert (isequal (setdiff([x 1], x), sym(1))) + assert (isempty (setdiff(x, x))) ***** test - % more differences 1, these don't simplify in sympy (as of 2016-01) - expr = (x+1)^2 == x*x + 2*x + 1; - assert (~logical(expr)) - assert (isAlways(expr)) + A = interval(sym(1), 3); + B = interval(sym(2), 5); + C = setdiff(A, B); + assert( isequal( C, interval(sym(1), 2, false, true))) +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@sym/size.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/size.m ***** test - % more differences 2 - expr = sin(2*x) == 2*sin(x)*cos(x); - assert (~logical(expr)) - assert (isAlways(expr)) + a = sym([1 2 3]); + [n,m] = size(a); + assert (n == 1 && m == 3) ***** test - % more differences 3, false - expr = x*(x+y) == x^2 + x*y + 1; - assert (~logical(expr)) - assert (~isAlways(expr)) - assert (~isAlways(expr, 'unknown', 'error')) + a = sym([1 2 3]); + n = size(a); + assert (isequal (n, [1 3])) ***** test - % logically not equal, math equal - exprn = x*(x+y) ~= x^2 + x*y; - assert (logical(exprn)) - assert (~isAlways(exprn)) + %% size, numel, length + a = sym([1 2 3; 4 5 6]); + assert (isa (size(a), 'double')) + assert (isa (numel(a), 'double')) + assert (isa (length(a), 'double')) + assert (isequal (size(a), [2 3])) + assert (length(a) == 3) + assert (numel(a) == 6) + a = sym([1; 2; 3]); + assert (isequal (size(a), [3 1])) + assert (length(a) == 3) + assert (numel(a) == 3) ***** test - % logically not equal, math not equal - exprn = x*(x+y) ~= x^2 + x*y + 1; - assert (logical(exprn)) - assert (isAlways(exprn)) + %% size by dim + a = sym([1 2 3; 4 5 6]); + n = size(a, 1); + assert (n == 2) + m = size(a, 2); + assert (m == 3) + a = sym([1 2 3]'); + n = size(a, 1); + assert (n == 3) + m = size(a, 2); + assert (m == 1) +***** xtest + % symbolic-size matrices + syms n m integer + A = sym('A', [n m]); + d = size(A); + assert (~isa(d, 'sym')) + assert (isnumeric(d)) + assert (isequaln (d, [NaN NaN])) +!!!!! known failure +assert (isequaln (d, [NaN, NaN])) failed +***** xtest + % half-symbolic-size matrices + % FIXME: will fail until size stop lying by saying 1x1 + syms n integer + A = sym('A', [n 3]); + assert (isequaln (size(A), [NaN 3])) + A = sym('A', [4 n]); + assert (isequaln (size(A), [4 NaN])) +!!!!! known failure +assert (isequaln (size (A), [NaN, 3])) failed +***** xtest + % half-symbolic-size empty matrices + % FIXME: will fail until size stop lying by saying 1x1 + syms n integer + A = sym('A', [n 0]); + assert (isequaln (size(A), [NaN 0])) +!!!!! known failure +assert (isequaln (size (A), [NaN, 0])) failed +7 tests, 4 passed, 3 known failures, 0 skipped +[inst/@sym/rows.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/rows.m ***** test - % equal and not equal - e1 = sin(x)^2 + cos(x)^2 == 1; - e2 = sin(x)^2 + cos(x)^2 == 2; - assert (~logical(e1)) - assert (isAlways(e1)) - assert (~logical(e2)) - assert (~isAlways(e2)) - assert (~isAlways(e2, 'unknown', 'error')) -***** error isAlways(x, 'unknown', 'kevin') -***** error isAlways(x, 'unknown') -***** error isAlways(x, 'kevin', 'true') -***** error - a = [x*(x+y)==x^2+x*y x==y]; - b = isAlways(a, 'unknown', 'error'); -***** error - a = x==y; - b = isAlways(a, 'unknown', 'error'); + a = sym([1 2 3]); + assert (rows(a) == 1) ***** test - % array, unknown keyword - a = [x==x x==x+1 x==y x*(x+y)==x^2+x*y cos(x)^2+sin(x)^2==2]; - b = isAlways(a, 'unknown', false); - c = isAlways(a, 'unknown', 'false'); - expect = [true false false true false]; - assert (islogical(b)) - assert (isequal (b, expect)) - assert (isequal (c, expect)) - b = isAlways(a, 'unknown', true); - c = isAlways(a, 'unknown', 'true'); - expect = [true false true true false]; - assert (islogical(b)) - assert (isequal (b, expect)) - assert (isequal (c, expect)) + a = sym([1 2 3; 4 5 6]); + assert (rows(a) == 2) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/logspace.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/logspace.m ***** test - % ineq - e = x*(x+y) <= x^2 + x*y + 1; - assert (~logical(e)) - assert (isAlways(e)) - e = x*(x+y) <= x^2 + x*y; - assert (~logical(e)) - assert (isAlways(e)) -21 tests, 21 passed, 0 known failure, 0 skipped -[inst/@sym/asin.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/asin.m -***** error asin (sym(1), 2) -***** assert (isequaln (asin (sym(nan)), sym(nan))) + % default argument for N + A = logspace(0, 2); + assert (length (A) == 50); +***** test + % special case: pi as end pt + A = logspace(-sym(3), sym(pi), 3); + assert (isequal (A(end), sym(pi))) +***** test + A = logspace(-sym(4), 0, 3); + B = [sym(1)/10000 sym(1)/100 sym(1)]; + assert (isequal (A, B)) +***** test + % vpa support, might need recent sympy for sympy issue #10063 + n = 32; + A = logspace(-vpa(1,n), 0, 3); + B = [10^(-vpa(1,n)) 10^(-vpa(sym(1)/2,n)) vpa(1,n)]; + assert (all (A == B)) + assert (max(abs(double(A) - logspace(-1, 0, 3))) < 1e-15) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/erfi.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/erfi.m +***** error erfi (sym(1), 2) +***** assert (isequaln (erfi (sym(nan)), sym(nan))) ***** shared x, d - d = 1; - x = sym('1'); + d = 0; + x = sym('0'); ***** test - f1 = asin(x); - f2 = asin(d); + f1 = erfi(x); + f2 = 0; assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = asin(A); - f2 = asin(D); + f1 = erfi(A); + f2 = 0; + f2 = [f2 f2; f2 f2]; assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = asin (d); - f = asin (y); + A = erfi (d); + f = erfi (y); h = function_handle (f); B = h (d); assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/tanh.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/tanh.m -***** error tanh (sym(1), 2) -***** assert (isequaln (tanh (sym(nan)), sym(nan))) +[inst/@sym/harmonic.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/harmonic.m +***** error harmonic (sym(1), 2) +***** xtest + assert (isequaln (harmonic (sym(nan)), sym(nan))) +!!!!! known failure +assert (isequaln (harmonic (sym (nan)), sym (nan))) failed +***** assert (isequal (harmonic (sym(0)), sym(0))) +***** assert (isinf (harmonic (sym(inf)))) +***** assert (isequal (harmonic (sym([9 10])), [sym(7129)/2520 sym(7381)/2520])) +***** test + % round trip + y = sym('y'); + A = harmonic (7); + f = harmonic (y); + h = function_handle (f); + B = h (7); + assert (A, B, -eps) +6 tests, 5 passed, 1 known failure, 0 skipped +[inst/@sym/reshape.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/reshape.m +***** test + d = [2 4 6; 8 10 12]; + a = sym(d); + assert (isequal (reshape(a, [1 6]), reshape(d, [1 6]))) + assert (isequal (reshape(a, 1, 6), reshape(d, 1, 6))) + assert (isequal (reshape(a, 2, 3), reshape(d, 2, 3))) + assert (isequal (reshape(a, 3, 2), reshape(d, 3, 2))) + assert (isequal (reshape(a, 6, 1), reshape(d, 6, 1))) +***** shared x, a, d + syms x + a = [1 x^2 x^4; x x^3 x^5]; + d = [0 2 4; 1 3 5]; + +***** test + b = reshape(a, [1 6]); + assert (isequal (size(b), [1 6])) + assert (isequal (b, x.^reshape(d,1,6))) + +***** test + b = reshape(a, [6 1]); + assert (isequal (size(b), [6 1])) + assert (isequal (b, x.^reshape(d,6,1))) + b = reshape(b, size(a)); + assert (isequal (size(b), [2 3])) + assert (isequal (b, a)) + +***** test + b = a(:); + assert( isequal (size(b), [6 1])) + assert( isequal (b, x.^(d(:)))) + +***** test + % reshape scalar + assert (logical( reshape(x, 1, 1) == x )) + assert (logical( reshape(x, [1 1]) == x )) +***** shared a + syms a +***** error reshape(a, 2, 1) +***** error reshape(a, 1, 2) +***** error reshape(a, 1, 1, 1) +***** error reshape(a, [1, 1, 1]) +9 tests, 9 passed, 0 known failure, 0 skipped +[inst/@sym/acos.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/acos.m +***** error acos (sym(1), 2) +***** assert (isequaln (acos (sym(nan)), sym(nan))) ***** shared x, d d = 1; x = sym('1'); ***** test - f1 = tanh(x); - f2 = tanh(d); + f1 = acos(x); + f2 = acos(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = tanh(A); - f2 = tanh(D); + f1 = acos(A); + f2 = acos(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = tanh (d); - f = tanh (y); + A = acos (d); + f = acos (y); h = function_handle (f); B = h (d); assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/setxor.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/setxor.m +[inst/@sym/laguerreL.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/laguerreL.m +***** shared x + syms x +***** assert (isequal (laguerreL(0, x), sym(1))) +***** assert (isequal (laguerreL(1, x), 1-x)) +***** assert (isequal (laguerreL(2, x), x^2/2 - 2*x + 1)) +***** error laguerreL(x) +***** error laguerreL(1, 2, x, 3) +***** shared ***** test - A = sym([1 2 3]); - B = sym([1 2 4]); - C = setxor(A, B); - D1 = sym([3 4]); - D2 = sym([4 3]); - assert (isequal (C, D1) || isequal (C, D2)) + syms x + assert (isequal (laguerreL (-3, x), exp(x)*(x^2/2 + 2*x + 1))) ***** test - % one nonsym - A = sym([1 2 3]); - B = [1 2 4]; - C = setxor(A, B); - D1 = sym([3 4]); - D2 = sym([4 3]); - assert (isequal (C, D1) || isequal (C, D2)) + syms x n + L = laguerreL([2 n], x); + expected = [laguerreL(2, x) laguerreL(n, x)]; + assert (isequal (L, expected)) ***** test - % empty - A = sym([1 2 3]); - C = setxor(A, A); - assert (isempty (C)) + syms x y + L = laguerreL([1; 2], [x; y]); + expected = [laguerreL(1, x); laguerreL(2, y)]; + assert (isequal (L, expected)) ***** test - % empty input - A = sym([1 2]); - C = setxor(A, []); - assert (isequal (C, A) || isequal (C, sym([2 1]))) + syms x n + assert (isequal (laguerreL(n, 0, x), laguerreL(n, x))) +***** shared x, y, n + syms x y n +***** assert (isequal (laguerreL([1 n], 0, x), laguerreL([1 n], x))) ***** test - % scalar - syms x - assert (isequal (setxor([x 1], x), sym(1))) - assert (isempty (setxor(x, x))) + L = laguerreL([1; n], [pi; 0], [x; y]); + expected = [laguerreL(1, pi, x); laguerreL(n, 0, y)]; + assert (isequal (L, expected)) ***** test - A = interval(sym(1), 3); - B = interval(sym(2), 5); - C = setxor(A, B); - D = union (interval (sym(1), 2, false, true), interval (sym(3), 5, true, false)); - assert( isequal( C, D)) -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@sym/acosh.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/acosh.m -***** error acosh (sym(1), 2) -***** assert (isequaln (acosh (sym(nan)), sym(nan))) + L = laguerreL([1 n], [pi 0], x); + expected = [laguerreL(1, pi, x) laguerreL(n, 0, x)]; + assert (isequal (L, expected)) +***** test + L = laguerreL([1 n], pi, [x y]); + expected = [laguerreL(1, pi, x) laguerreL(n, pi, y)]; + assert (isequal (L, expected)) +***** test + L = laguerreL(1, [pi 0], [x y]); + expected = [laguerreL(1, pi, x) laguerreL(1, 0, y)]; + assert (isequal (L, expected)) +***** test + L = laguerreL([1 n], pi, x); + expected = [laguerreL(1, pi, x) laguerreL(n, pi, x)]; + assert (isequal (L, expected)) +***** test + L = laguerreL(1, [pi 0], x); + expected = [laguerreL(1, pi, x) laguerreL(1, 0, x)]; + assert (isequal (L, expected)) +***** test + L = laguerreL(1, pi, [x y]); + expected = [laguerreL(1, pi, x) laguerreL(1, pi, y)]; + assert (isequal (L, expected)) +***** test + % round trip + f = laguerreL (n, x); + h = function_handle (f); + A = h (1, 3.2); + B = laguerreL (1, 3.2); + assert (A, B) + A = h ([1 2], [3.3 4.4]); + B = laguerreL ([1 2], [3.3 4.4]); + assert (A, B) +***** error + % round trip + f = laguerreL (n, y, x); + h = function_handle (f); +19 tests, 19 passed, 0 known failure, 0 skipped +[inst/@sym/exp.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/exp.m +***** error exp (sym(1), 2) +***** assert (isequaln (exp (sym(nan)), sym(nan))) ***** shared x, d d = 1; x = sym('1'); ***** test - f1 = acosh(x); - f2 = acosh(d); + f1 = exp(x); + f2 = exp(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = acosh(A); - f2 = acosh(D); + f1 = exp(A); + f2 = exp(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - A = acosh (d); - f = acosh (y); + A = exp (d); + f = exp (y); h = function_handle (f); B = h (d); assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/ismatrix.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ismatrix.m -***** assert(ismatrix(sym('x'))) -***** assert(ismatrix(sym([1 2 3]))) -***** assert(ismatrix(sym([1; 2]))) -***** assert(ismatrix(sym([1 2; 3 4]))) -***** assert(ismatrix(sym([]))) -***** assert(ismatrix(sym(ones(1,0)))) -***** assert(ismatrix(sym(ones(0,3)))) -7 tests, 7 passed, 0 known failure, 0 skipped -[inst/@sym/display.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/display.m -***** test - assert(true) -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@sym/cbrt.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cbrt.m -***** error cbrt (sym(1), 2) -***** assert (isequaln (cbrt (sym(nan)), sym(nan))) +[inst/@sym/acsc.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/acsc.m +***** error acsc (sym(1), 2) +***** assert (isequaln (acsc (sym(nan)), sym(nan))) ***** shared x, d - d = 2; - x = sym('2'); + d = 1; + x = sym('1'); ***** test - f1 = cbrt(x); - f2 = 1.2599210498948731647; + f1 = acsc(x); + f2 = acsc(d); assert( abs(double(f1) - f2) < 1e-15 ) ***** test D = [d d; d d]; A = [x x; x x]; - f1 = cbrt(A); - f2 = 1.2599210498948731647; - f2 = [f2 f2; f2 f2]; + f1 = acsc(A); + f2 = acsc(D); assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test % round trip y = sym('y'); - if (exist ('OCTAVE_VERSION', 'builtin')) - A = cbrt (d); - else - % Issue #742 - A = d^(1/3); - end - f = cbrt (y); + A = acsc (d); + f = acsc (y); h = function_handle (f); B = h (d); assert (A, B, -eps) 5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/resize.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/resize.m +[inst/@sym/orth.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/orth.m ***** test - B = sym([1 0 0; 0 0 0]); - assert (isequal (resize (sym(1), 2, 3), B)) - assert (isequal (resize (sym(1), [2 3]), B)) + A = [1 2; 3 6]; + K = orth(A); + L = orth(sym(A)); + assert (isequal (size(L), [2 1])) + dif1 = abs (double(L) - K); + dif2 = abs (double(L) + K); + assert (all (dif1 < 1e-15) || all (dif2 < 1e-15)) ***** test - B = sym([1 0; 0 0]); - assert (isequal (resize (sym(1), 2), B)) + A = [1; 3]; + K = orth(A); + L = orth(sym(A)); + assert (isequal (size(L), [2 1])) + dif1 = abs (double(L) - K); + dif2 = abs (double(L) + K); + assert (all (dif1 < 1e-16) || all (dif2 < 1e-16)) ***** test - A = sym([pi 2; 3 4]); - assert (isequal (resize (A, 1), sym(pi))) -***** assert (isequal (size (resize (sym(1), 0, 0)), [0 0])) -***** assert (isequal (size (resize (sym(1), 6, 0)), [6 0])) -***** assert (isequal (size (resize (sym(1), 0, 3)), [0 3])) -***** error resize (sym(1)) -***** error resize (sym(1), 2, 3, 4) -***** error resize (sym(1), [2 3 4]) -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/fresnelc.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/fresnelc.m -***** error fresnelc (sym(1), 2) + A = sym([1 2; 3 4]); + L = orth(sym(A)); + assert (isequal (size(L), [2 2])) + v = L(:, 1); + w = L(:, 2); + assert (isAlways (v' * v == 1)) + assert (isAlways (w' * w == 1)) + assert (isAlways (v' * w == 0)) ***** test - a = fresnelc(sym(0)); - assert (isequal (a, sym(0))) + A = sym([1 1; 1 0; 1 0]); + L = orth(sym(A)); + assert (isequal (size(L), [3 2])) + v = L(:, 1); + w = L(:, 2); + assert (isAlways (v' * v == 1)) + assert (isAlways (w' * w == 1)) + assert (isAlways (v' * w == 0)) + % y and z components must be equal + assert (isAlways (v(2) == v(3))) + assert (isAlways (w(2) == w(3))) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/nchoosek.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/nchoosek.m +***** assert (isequal (nchoosek(sym(5), sym(2)), sym(10))) +***** assert (isequal (nchoosek(sym(5), 2), sym(10))) +***** assert (isequal (nchoosek(5, sym(2)), sym(10))) +***** assert (isequal (nchoosek(sym(10), 0), 1)) +***** assert (isequal (nchoosek(sym(10), -1), 0)) ***** test - b = fresnelc(sym('oo')); - assert (isequal (b, sym(1)/2)) + n = sym('n', 'nonnegative', 'integer'); + assert (isequal (nchoosek (n, n), sym(1))) ***** test - % values in a matrix - syms x - a = fresnelc([sym(0) sym('oo') x 1]); - b = [sym(0) sym(1)/2 fresnelc(x) fresnelc(sym(1))]; - assert (isequal (a, b)) + n = sym('n', 'integer'); + q = nchoosek(n, 2); + w = subs(q, n, 5); + assert (isequal (w, 10)) ***** test - % round trip - syms x - f = fresnelc (x); - h = function_handle (f); - A = h (1.1); - B = fresnelc (1.1); - assert (A, B) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/assumeAlso.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/assumeAlso.m + n = sym('n', 'integer'); + k = sym('k', 'integer'); + q = nchoosek(n, k); + w = subs(q, {n k}, {5 2}); + assert (isequal (w, 10)) +***** test + % negative input + assert (isequal (nchoosek (sym(-2), sym(5)), sym(-6))) +***** test + % complex input + n = sym(1 + 3i); + k = sym(5); + A = nchoosek (n, k); + B = gamma (n + 1) / (gamma (k + 1) * gamma (n - k + 1)); + assert (double (A), double (B), -2*eps) +***** test + % complex input + n = sym(-2 + 3i); + k = sym(1 + i); + A = nchoosek (n, k); + B = gamma (n + 1) / (gamma (k + 1) * gamma (n - k + 1)); + assert (double (A), double (B), -2*eps) +11 tests, 11 passed, 0 known failure, 0 skipped +[inst/@sym/degree.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/degree.m +***** error degree (sym(1), 2, 3) ***** test syms x - x = assumeAlso(x, 'positive'); - a = assumptions(x); - assert(strcmp(a, 'x: positive')) -***** error - syms x - x = assumeAlso (x, x); + assert (isequal (degree(x^3), 3)) + assert (isequal (degree(x^3 + 6), 3)) ***** test - syms x positive - x = assumeAlso(x, 'integer'); - [tilde, a] = assumptions(x, 'dict'); - assert(a{1}.integer) - assert(a{1}.positive) + % specify variable + syms x y + p = x^2 + y*x + 1; + assert (isequal (degree(p), 2)) + assert (isequal (degree(p, x), 2)) + assert (isequal (degree(p, y), 1)) ***** test - % multiple assumptions - syms x positive - x = assumeAlso(x, 'integer', 'even'); - [tilde, a] = assumptions(x, 'dict'); - assert(a{1}.integer) - assert(a{1}.positive) - assert(a{1}.even) + syms x a oo + assert (isequal (degree(x^3, a), 0)) + assert (isequal (degree(sym(1), a), 0)) + assert (isequal (degree(sym(0), a), -oo)) +***** xtest + % constant inputs + syms oo + assert (isequal (degree(sym(1)), 0)) + assert (isequal (degree(sym(0)), -oo)) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/abs.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/abs.m +***** error abs (sym(1), 2) +***** assert (isequaln (abs (sym(nan)), sym(nan))) +***** shared x, d + d = -1; + x = sym('-1'); ***** test - % multiple assumptions - syms x integer - x = assumeAlso (x, 'even', 'positive'); - [tilde, a] = assumptions (x, 'dict'); - assert (a{1}.integer) - assert (a{1}.even) - assert (a{1}.positive) + f1 = abs(x); + f2 = abs(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - % has output so avoids workspace - syms x positive - x2 = x; - f = sin(x); - assumeAlso(x, 'integer'); - a = assumptions(x); - assert(strcmp(a, 'x: positive, integer') || strcmp(a, 'x: integer, positive')) - a = assumptions(x2); - assert(strcmp(a, 'x: positive, integer') || strcmp(a, 'x: integer, positive')) - a = assumptions(f); - assert(strcmp(a, 'x: positive, integer') || strcmp(a, 'x: integer, positive')) + D = [d d; d d]; + A = [x x; x x]; + f1 = abs(A); + f2 = abs(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test - % has no output so does workspace - syms x positive - x2 = x; - f = sin(x); - assumeAlso(x, 'integer'); - a = assumptions(x); - assert(strcmp(a, 'x: positive, integer') || strcmp(a, 'x: integer, positive')) - a = assumptions(x2); - assert(strcmp(a, 'x: positive, integer') || strcmp(a, 'x: integer, positive')) - a = assumptions(f); - assert(strcmp(a, 'x: positive, integer') || strcmp(a, 'x: integer, positive')) -***** error - syms a - assumeAlso (a > 0) + % round trip + y = sym('y'); + A = abs (d); + f = abs (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/all.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/all.m ***** test - syms x y - assumeAlso ([x y], 'even') - assert (strcmp (assumptions (x), 'x: even')) - assert (strcmp (assumptions (y), 'y: even')) + % matrix + a = [0 3; 1 2]; + s = sym (a); + assert (isequal (all (s), all (a))) + assert (isequal (all (s,1), all (a,1))) + assert (isequal (all (s,2), all (a,2))) ***** test - syms x y positive - f = sin (2*x); - assumeAlso ([x y], 'even') - assert (strcmp (assumptions (x), 'x: even, positive') || strcmp (assumptions (x), 'x: positive, even')) - assert (strcmp (assumptions (y), 'y: even, positive') || strcmp (assumptions (y), 'y: positive, even')) - assert (strcmp (assumptions (f), 'x: even, positive') || strcmp (assumptions (f), 'x: positive, even')) + % vector + a = [1 2 3]; + s = sym (a); + assert (isequal (all (s), all (a))) + assert (isequal (all (s,1), all (a,1))) + assert (isequal (all (s,2), all (a,2))) ***** test - % with output, original x and y are unchanged - syms x y positive - f = sin (2*x); - [p, q] = assumeAlso ([x y], 'even'); - assert (strcmp (assumptions (x), 'x: positive')) - assert (strcmp (assumptions (y), 'y: positive')) - assert (strcmp (assumptions (f), 'x: positive')) - assert (strcmp (assumptions (p), 'x: even, positive') || strcmp (assumptions (p), 'x: positive, even')) - assert (strcmp (assumptions (q), 'y: even, positive') || strcmp (assumptions (q), 'y: positive, even')) -11 tests, 11 passed, 0 known failure, 0 skipped + % should fail on symbols + syms x + s = [1 2 x]; + try + all (s) + waserr = false; + catch + waserr = true; + end + assert (waserr) +3 tests, 3 passed, 0 known failure, 0 skipped [inst/@sym/subsref.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/subsref.m ***** shared a,b @@ -12559,2925 +13209,1920 @@ ***** test % older array refs test assert (logical(b(1,1) == a(1,1))) - assert (logical(b(3,1) == a(3,1))) - assert (logical(b(1,3) == a(1,3))) - assert (logical(b(4,4) == a(4,4))) -***** test - % older array refs test: linear indices - assert (logical(b(1) == a(1))) - assert (logical(b(3) == a(3))) - assert (logical(b(13) == a(13))) -***** test - % older array refs test: end - assert (all(all(logical( b(end,1) == a(end,1) )))) - assert (all(all(logical( b(2,end) == a(2,end) )))) - assert (all(all(logical( b(end,end) == a(end,end) )))) - assert (all(all(logical( b(end-1,1) == a(end-1,1) )))) - assert (all(all(logical( b(2,end-1) == a(2,end-1) )))) - assert (all(all(logical( b(end-1,end-1) == a(end-1,end-1) )))) -***** shared -***** test - % older slicing tests - syms x - a = [1 2 3 4 5 6]; a = [a; 3*a; 5*a; 2*a; 4*a]; - b = sym(a); - assert (isequal( b(:,1), a(:,1) )) - assert (isequal( b(:,2), a(:,2) )) - assert (isequal( b(1,:), a(1,:) )) - assert (isequal( b(2,:), a(2,:) )) - assert (isequal( b(:,:), a(:,:) )) - assert (isequal( b(1:3,2), a(1:3,2) )) - assert (isequal( b(1:4,:), a(1:4,:) )) - assert (isequal( b(1:2:5,:), a(1:2:5,:) )) - assert (isequal( b(1:2:4,:), a(1:2:4,:) )) - assert (isequal( b(2:2:4,3), a(2:2:4,3) )) - assert (isequal( b(2:2:4,3), a(2:2:4,3) )) -***** test - % 2D arrays - b = [1:4]; b = [b; 3*b; 5*b]; - a = sym(b); - I = rand(size(b)) > 0.5; - assert (isequal (a(I), b(I))) - I = I(:); - assert (isequal (a(I), b(I))) - I = I'; - assert (isequal (a(I), b(I))) - I = logical(zeros(size(b))); - assert (isequal (a(I), b(I))) -***** test - % 1D arrays, does right with despite warning - r = [1:6]; - ar = sym(r); - c = r'; - ac = sym(c); - Ir = rand(size(r)) > 0.5; - Ic = rand(size(c)) > 0.5; - assert (isequal (ar(Ir), r(Ir))) - assert (isequal (ac(Ic), c(Ic))) - assert (isequal (ar(Ic), r(Ic))) - assert (isequal (ac(Ir), c(Ir))) -***** test - % rccross tests - B = [1 2 3 4; 5 6 7 9; 10 11 12 13]; - A = sym(B); - assert (isequal (A([1 3],[2 3]), B([1 3], [2 3]) )) - assert (isequal (A(1,[2 3]), B(1,[2 3]) )) - assert (isequal (A([1 2],4), B([1 2],4) )) - assert (isequal (A([2 1],[4 2]), B([2 1],[4 2]) )) - assert (isequal (A([],[]), B([],[]) )) -***** error - % issue #445 - A = sym([10 11]); - A(1.1) -***** error - % issue #445 - A = sym([10 11]); - A(sym(4)/3) -***** error - % issue #445 - A = sym([1 2; 3 4]); - A(1.1, 1) -***** error - % issue #445 - A = sym([1 2; 3 4]); - A(1, sym(4)/3) -***** error - A = sym([1 2; 3 4]); - A(5) -***** shared a, b - a = [1 2 3 5; 4 5 6 9; 7 5 3 2]; - b = sym (a); -***** test - c = true; - assert (isequal (a(c), b(c))) - c = false; - assert (isequal (a(c), b(c))) -***** test - c = [false true]; - assert (isequal (a(c), b(c))) - d = c | true; - assert (isequal (a(d), b(d))) - d = c & false; - assert (isequal (a(d), b(d))) -***** test - c = [false true false true; true false true false; false true false true]; - assert (isequal (a(c), b(c))) - d = c | true; - assert (isequal (a(d), b(d))) - d = c & false; - assert (isequal (a(d), b(d))) -***** test - c = [false true false true false]; - assert (isequal (a(c), b(c))) - d = c | true; - assert (isequal (a(d), b(d))) - d = c & false; - assert (isequal (a(d), b(d))) -***** test - c = [false; true; false; true; false]; - assert (isequal (a(c), b(c))) - d = c | true; - assert (isequal (a(d), b(d))) - d = c & false; - assert (isequal (a(d), b(d))) -***** test - c = [false true; false true; true false]; - assert (isequal (a(c), b(c))) - d = c | true; - assert (isequal (a(d), b(d))) - d = c & false; - assert (isequal (a(d), b(d))) -***** shared -***** test - % Orientation of empty results of logical indexing on row or column vectors - r = [1:6]; - c = r'; - ar = sym(r); - ac = sym(c); - assert (isequal (ar(false), r(false))) - assert (isequal (ac(false), c(false))) - assert (isequal (ar(false (1, 6)), r(false (1, 6)))) - assert (isequal (ac(false (1, 6)), c(false (1, 6)))) - assert (isequal (ar(false (6, 1)), r(false (6, 1)))) - assert (isequal (ac(false (6, 1)), c(false (6, 1)))) -50 tests, 50 passed, 0 known failure, 0 skipped -[inst/@sym/acsch.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/acsch.m -***** error acsch (sym(1), 2) -***** assert (isequaln (acsch (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); -***** test - f1 = acsch(x); - f2 = acsch(d); - assert( abs(double(f1) - f2) < 1e-15 ) -***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = acsch(A); - f2 = acsch(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) -***** test - % round trip - y = sym('y'); - A = acsch (d); - f = acsch (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/tan.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/tan.m -***** error tan (sym(1), 2) -***** assert (isequaln (tan (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); -***** test - f1 = tan(x); - f2 = tan(d); - assert( abs(double(f1) - f2) < 1e-15 ) -***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = tan(A); - f2 = tan(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) -***** test - % round trip - y = sym('y'); - A = tan (d); - f = tan (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/horner.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/horner.m -***** error horner (sym(1), 2, 3) -***** assert (isAlways (horner(sym(1)) == 1)) -***** test - syms x - assert (isAlways (horner(x) == x)) -***** test - syms x a - p = a^2 + a*x + 2*a + 2*x; - assert (isequal (horner (p, a), a*(a+x+2) + 2*x)) - q = a^2 + 2*a + x*(a + 2); - assert (isequal (horner (p, x), q)) - assert (isequal (horner (p), q)) -***** test - syms x - p = poly2sym ([2 4 6 8], x); - q = horner (p); - assert (isAlways (p == q)) - assert (isAlways (horner(2*x^3 + 4*x^2 + 6*x + 8) == q)) -***** test - % non-sym input - syms x - assert (isequal (horner(6, x), sym(6))) -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@sym/lu.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/lu.m -***** test - % scalar - [l, u, p] = lu(sym(6)); - assert (isequal (l, sym(1))) - assert (isequal (u, sym(6))) - assert (isequal (p, sym(1))) - syms x - [l, u, p] = lu(x); - assert (isequal (l*u, p*x)) - [l, u] = lu(x); - assert (isequal (l*u, x)) -***** test - % perm - A = sym(fliplr(2*eye(3))); - [L, U, P] = lu(A); - assert (isequal (L*U, P*A)) - [L, U, P] = lu(A, 'matrix'); - assert (isequal (L*U, P*A)) - [L, U, p] = lu(A, 'vector'); - assert (isequal (L*U, A(p,:))) - [L, U] = lu(A); - assert (isequal (L*U, A)) -***** test - % p is col vectpr - A = sym([0 2; 3 4]); - [L, U, p] = lu(A, 'vector'); - assert(iscolumn(p)) -***** test - % simple matrix - A = [1 2; 3 4]; - B = sym(A); - [L, U, P] = lu(B); - assert (isequal (L*U, P*B)) - assert (isequal (U(2,1), sym(0))) - % needs pivot - A = [0 2; 3 4]; - B = sym(A); - [L, U, P] = lu(B); - [Ld, Ud, Pd] = lu(A); - assert (isequal (L*U, P*A)) - assert (isequal (U(2,1), sym(0))) - % matches regular LU - assert ( max(max(double(L)-Ld)) <= 10*eps) - assert ( max(max(double(U)-Ud)) <= 10*eps) - assert ( isequal (P, Pd)) -***** test - % rectangular - A = sym([1 2; 3 4; 5 6]); - [L, U] = lu (A); - assert (isequal (L*U, A)) -***** test - % rectangular - A = sym([1 2 3; 4 5 6]); - [L, U] = lu (A); - assert (isequal (L*U, A)) -***** test - % rectangular, repeated row - A = sym([1 2 3; 2 4 6]); - [L, U] = lu (A); - assert (isequal (L*U, A)) -***** test - % rectangular, needs permutation - A = sym([0 0 0; 1 2 3]); - [L, U] = lu (A); - assert (isequal (L*U, A)) - assert (~isequal (tril (L), L)) - [L, U, P] = lu (A); - assert (isequal (L*U, P*A)) - assert (isequal (tril (L), L)) -8 tests, 8 passed, 0 known failure, 0 skipped -[inst/@sym/ssinint.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ssinint.m -***** assert (isequal (ssinint(sym(0)), -sym(pi)/2)) -***** test - A = ssinint (sym ([0 1])); - B = [-pi/2 -0.62471325642771360426]; - assert( all(all( abs(double(A)-B) < 1e-15 ))) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/ezmesh.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ezmesh.m -***** error - syms u v t - ezmesh(u*v, 2*u*v, 3*v*t) -***** error - syms u v t - ezmesh(u*v, 2*u*v, u*v*t) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/atanh.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/atanh.m -***** error atanh (sym(1), 2) -***** assert (isequaln (atanh (sym(nan)), sym(nan))) -***** shared x, d - d = 1/2; - x = sym('1/2'); -***** test - f1 = atanh(x); - f2 = atanh(d); - assert( abs(double(f1) - f2) < 1e-15 ) -***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = atanh(A); - f2 = atanh(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) -***** test - % round trip - y = sym('y'); - A = atanh (d); - f = atanh (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/csc.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/csc.m -***** error csc (sym(1), 2) -***** assert (isequaln (csc (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); -***** test - f1 = csc(x); - f2 = csc(d); - assert( abs(double(f1) - f2) < 1e-15 ) -***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = csc(A); - f2 = csc(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) -***** test - % round trip - y = sym('y'); - A = csc (d); - f = csc (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/lhs.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/lhs.m -***** test - syms x y - f = x + 1 == 2*y; - assert (isequal (lhs(f), x + 1)) - assert (isequal (rhs(f), 2*y)) -***** test - syms x y - f = x + 1 < 2*y; - assert (isequal (lhs(f), x + 1)) - assert (isequal (rhs(f), 2*y)) -***** test - syms x y - f = x + 1 >= 2*y; - assert (isequal (lhs(f), x + 1)) - assert (isequal (rhs(f), 2*y)) -***** test - syms x y - A = [x == y 2*x < 2*y; 3*x > 3*y 4*x <= 4*y; 5*x >= 5*y x < 0]; - L = [x 2*x; 3*x 4*x; 5*x x]; - R = [y 2*y; 3*y 4*y; 5*y 0]; - assert (isequal( lhs(A), L)) - assert (isequal( rhs(A), R)) -***** error - syms x - lhs(x) -***** error - lhs(sym(true)) -***** error - syms x - A = [1 + x == 2*x sym(6)]; - lhs(A) -7 tests, 7 passed, 0 known failure, 0 skipped -[inst/@sym/sin.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sin.m -***** error sin (sym(1), 2) -***** assert (isequaln (sin (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); -***** test - f1 = sin(x); - f2 = sin(d); - assert( abs(double(f1) - f2) < 1e-15 ) -***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = sin(A); - f2 = sin(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) -***** test - % round trip - y = sym('y'); - A = sin (d); - f = sin (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/cot.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cot.m -***** error cot (sym(1), 2) -***** assert (isequaln (cot (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); -***** test - f1 = cot(x); - f2 = cot(d); - assert( abs(double(f1) - f2) < 1e-15 ) -***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = cot(A); - f2 = cot(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) -***** test - % round trip - y = sym('y'); - A = cot (d); - f = cot (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/sort.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sort.m -***** error sort (sym(1), 2) -***** test - f = [sym(1), sym(0)]; - expected = sym([0, 1]); - assert (isequal (sort(f), expected)) -***** test - f = [sym(1)]; - expected = sym(1); - assert (isequal (sort(f), expected)) -***** test - f = [sym(3), sym(2), sym(6)]; - s = sort(f); - expected_s = sym([2, 3, 6]); - assert (isequal (s, expected_s)) -***** test - f = [sym(pi), sin(sym(2)), sqrt(sym(6))]; - s = sort(f); - expected_s = sym([sin(sym(2)), sqrt(sym(6)), sym(pi)]); - assert (isequal (s, expected_s)) -***** test - f = [sym(1), sym(2); sym(2), sym(pi); sym(pi), sym(1)]; - s = sort(f); - expected_s = ([sym(1), sym(1); sym(2), sym(2); sym(pi), sym(pi)]); - assert (isequal (s, expected_s)) -***** assert (isequal (sort(sym([])), sym([]))) -***** error sort([sym('x') 1]) -***** test - % but with assumptions, symbols can be sorted - p = sym('p', 'positive'); - n = sym('n', 'negative'); - expected_s = [n p]; - s = sort ([p n]); - assert (isequal (s, expected_s)) -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/cumsum.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cumsum.m -***** shared x, y - x = sym ('x'); - y = sym ('y'); -***** error cumsum (x, 1, 2) -***** assert (isequal (cumsum ([-x; -2*x; -3*x]), [-x; -3*x; -6*x])) -***** assert (isequal (cumsum ([x + 2i*y, 2*x + i*y]), [x + 2i*y, 3*x + 3i*y])) -***** assert (isequal (cumsum ([x, 2*x; 3*x, 4*x], 1), [1*x, 2*x; 4*x, 6*x] )) -***** assert (isequal (cumsum ([x, 2*x; 3*x, 4*x], 2), [1*x, 3*x; 3*x, 7*x] )) -***** test cumsum ([x, x], [2, 1]); # ensure behaves like builtin cumsum -***** test cumsum ([x, x], [1, -2]); # ensure behaves like builtin cumsum -***** error cumsum (x, []) -***** error cumsum (x, {1}) -***** error cumsum (x, struct('a', 1)) -***** error cumsum (x, x) -***** error cumsum (x, 0) -***** error cumsum (x, -1) -13 tests, 13 passed, 0 known failure, 0 skipped -[inst/@sym/besseli.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/besseli.m -***** test - X = [1 2 3; 4 5 6]; - ns = [sym(0) 1 -2; sym(1)/2 -sym(3)/2 pi]; - n = double(ns); - A = double(besseli(ns, X)); - B = besseli(n, X); - assert (all (all (abs (A - B) < 100*eps*abs(A)))) -***** test - % roundtrip - syms x - A = besseli(2, 10); - q = besseli(2, x); - h = function_handle(q); - B = h(10); - assert (abs (A - B) <= eps*abs(A)) -***** error besseli(sym('x')) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/zeta.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/zeta.m -***** error zeta (sym(1), 2, 3) -***** assert (isequaln (zeta (sym(nan)), sym(nan))) -***** test - f1 = zeta (sym(2)); - f2 = pi^2/6; - assert (double (f1), f2, -1e-15) -***** test - A = sym([0 2; 4 6]); - f1 = zeta (A); - f2 = [-1/2 pi^2/6; pi^4/90 pi^6/945]; - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) -***** test - % round trip - y = sym('y'); - f = zeta (y); - h = function_handle (f); - A = zeta (2); - B = h (2); - assert (A, B, -eps) -***** test - syms x - assert (isequal (zeta (0, x), zeta(x))) -***** test - % ensure its the nth deriv wrt x, not the n deriv - syms x n - F = zeta (n, x); - F = subs(F, n, 3); - assert (isequal (F, diff (zeta (x), x, x, x))) -7 tests, 7 passed, 0 known failure, 0 skipped -[inst/@sym/sinh.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sinh.m -***** error sinh (sym(1), 2) -***** assert (isequaln (sinh (sym(nan)), sym(nan))) -***** shared x, d - d = 1; - x = sym('1'); -***** test - f1 = sinh(x); - f2 = sinh(d); - assert( abs(double(f1) - f2) < 1e-15 ) -***** test - D = [d d; d d]; - A = [x x; x x]; - f1 = sinh(A); - f2 = sinh(D); - assert( all(all( abs(double(f1) - f2) < 1e-15 ))) -***** test - % round trip - y = sym('y'); - A = sinh (d); - f = sinh (y); - h = function_handle (f); - B = h (d); - assert (A, B, -eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/frac.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/frac.m -***** test - f1 = frac(sym(11)/10); - f2 = sym(1)/10; - assert (isequal (f1, f2)) -***** test - d = sym(-11)/10; - c = sym(9)/10; - assert (isequal (frac (d), c)) -***** test - d = sym(-19)/10; - c = sym(1)/10; - assert (isequal (frac (d), c)) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/ellipticK.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipticK.m -***** error ellipticK (sym(1), 2) -***** assert (isequal (ellipticK (sym (0)), sym (pi)/2)) -***** assert (isequal (ellipticK (sym (-inf)), sym (0))) -***** assert (double (ellipticK (sym (1)/2)), 1.854074677, 10e-10) -***** assert (double (ellipticK (sym (pi)/4)), 2.225253684, 10e-10) -***** assert (double (ellipticK (sym (-55)/10)), 0.9324665884, 10e-11) -***** test - % compare to double ellipke - m = 1/5; - ms = sym(1)/5; - [K, E] = ellipke (m); - assert (double (ellipticK (ms)), K, -1e-15) - assert (double (ellipticE (ms)), E, -1e-15) -***** test - % compare to double ellipke - if (exist ('OCTAVE_VERSION', 'builtin')) - m = -10.3; - ms = -sym(103)/10; - [K, E] = ellipke (m); - assert (double (ellipticK (ms)), K, -1e-15) - assert (double (ellipticE (ms)), E, -1e-15) - end -***** test - % compare to Maple - us = vpa (ellipticK (sym (7)), 40); - % > evalf(EllipticK(sqrt(7)), 40); - maple = vpa ('0.6168027921799632674669917683443602673441', 40) - ... - vpa ('0.9114898734184488922164103102629560336918j', 40); - assert (abs (double (maple - us)), 0, 1e-39) -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/fliplr.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/fliplr.m -***** test - % simple - syms x - A = [x 2; sym(pi) x]; - B = [2 x; x sym(pi)]; - assert (isequal (fliplr(A), B)) -***** test - % simple, odd # cols - syms x - A = [x 2 sym(pi); x 1 2]; - B = [sym(pi) 2 x; 2 1 x]; - assert (isequal (fliplr(A), B)) -***** test - % scalar - syms x - assert (isequal (fliplr(x), x)) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@sym/reshape.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/reshape.m -***** test - d = [2 4 6; 8 10 12]; - a = sym(d); - assert (isequal (reshape(a, [1 6]), reshape(d, [1 6]))) - assert (isequal (reshape(a, 1, 6), reshape(d, 1, 6))) - assert (isequal (reshape(a, 2, 3), reshape(d, 2, 3))) - assert (isequal (reshape(a, 3, 2), reshape(d, 3, 2))) - assert (isequal (reshape(a, 6, 1), reshape(d, 6, 1))) -***** shared x, a, d - syms x - a = [1 x^2 x^4; x x^3 x^5]; - d = [0 2 4; 1 3 5]; - -***** test - b = reshape(a, [1 6]); - assert (isequal (size(b), [1 6])) - assert (isequal (b, x.^reshape(d,1,6))) - -***** test - b = reshape(a, [6 1]); - assert (isequal (size(b), [6 1])) - assert (isequal (b, x.^reshape(d,6,1))) - b = reshape(b, size(a)); - assert (isequal (size(b), [2 3])) - assert (isequal (b, a)) - -***** test - b = a(:); - assert( isequal (size(b), [6 1])) - assert( isequal (b, x.^(d(:)))) - -***** test - % reshape scalar - assert (logical( reshape(x, 1, 1) == x )) - assert (logical( reshape(x, [1 1]) == x )) -***** shared a - syms a -***** error reshape(a, 2, 1) -***** error reshape(a, 1, 2) -***** error reshape(a, 1, 1, 1) -***** error reshape(a, [1, 1, 1]) -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/signIm.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/signIm.m -***** assert (isequal (signIm (sym(1)), sym(0))) -***** assert (isequal (signIm (sym(1) + 2i), sym(1))) -***** assert (isequal (signIm (sym(1) - 2i), sym(-1))) -***** test - % intermediate A looks bit weird, but it works - syms z - A = signIm (z); - assert (isequal (subs(A, z, 3+sym(4i)), sym(1))) - assert (isequal (subs(A, z, 3-sym(4i)), sym(-1))) -***** test - % really a @sym/sign test, but that one is autogen - z = 3 + sym(4i); - A = sign (z); - B = z / abs(z); - assert (double (A), double (B), eps) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/ifourier.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ifourier.m -***** error ifourier (sym(1), 2, 3, 4) -***** test - % matlab SMT compat - syms t r u x w - Pi=sym('pi'); - assert(logical( ifourier(exp(-abs(w))) == 1/(Pi*(x^2 + 1)) )) - assert(logical( ifourier(exp(-abs(x))) == 1/(Pi*(t^2 + 1)) )) - assert(logical( ifourier(exp(-abs(r)),u) == 1/(Pi*(u^2 + 1)) )) - assert(logical( ifourier(exp(-abs(r)),r,u) == 1/(Pi*(u^2 + 1)) )) -***** test - % basic - syms x w - Pi=sym('pi'); - assert(logical( ifourier(exp(-w^2/4)) == 1/(sqrt(Pi)*exp(x^2)) )) - assert(logical( ifourier(sqrt(Pi)/exp(w^2/4)) == exp(-x^2) )) -***** test - % Dirac delta tests - syms x w - Pi=sym('pi'); - assert(logical( ifourier(dirac(w-2)) == exp(2*1i*x)/(2*Pi) )) - assert (logical( ifourier(sym(2), w, x) == 2*dirac(x) )) -***** test - % advanced test - syms x w c d - Pi=sym('pi'); - f=(Pi*(dirac(x-c)+dirac(x+c))+2*Pi*1i*(-dirac(x+3*d)+dirac(x-3*d))+2/(x^2+1))/(2*Pi); - assert(logical( simplify(ifourier(cos(c*w)+2*sin(3*d*w)+exp(-abs(w)))-f) == 0 )) -***** xtest - % Inverse Fourier transform cannot recover non-smooth functions - % SymPy cannot evaluate correctly?? - syms x w - assert(logical( ifourier(2/(w^2 + 1)) == exp(-abs(x)) )) - assert(logical( ifourier(2/(w^2 + 1)) == heaviside(x)/exp(x) + heaviside(-x)*exp(x) )) - assert(logical( ifourier(-(w*4)/(w^4 + 2*w^2 + 1) )== -x*exp(-abs(x))*1i )) - assert(logical( ifourier(-(w*4)/(w^4 + 2*w^2 + 1) )== -x*(heaviside(x)/exp(x) + heaviside(-x)*exp(x))*1i )) -!!!!! known failure -assert (logical (ifourier (2 / (w ^ 2 + 1)) == exp (-abs (x)))) failed -***** error ifourier (sym('k', 'positive')*sym('k')) -***** test - % SMT compact, prefers k over symvar - syms k x y - assert (isequal (ifourier(y*exp(-k^2/4)), y/sqrt(sym(pi))*exp(-x^2))) -8 tests, 7 passed, 1 known failure, 0 skipped -[inst/@sym/cond.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cond.m -***** test - A = [1 2; 3 4]; - B = sym(A); - k1 = cond(A); - k2 = cond(B); - k3 = double(k2); - assert (k1 - k3 <= 100*eps) -***** test - % matrix with symbols - syms x positive - A = [x 0; sym(0) 2*x]; - k1 = cond(A); - assert (isequal (k1, sym(2))) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/atan2.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/atan2.m -***** error atan2 (1) -***** error atan2 (1, 2, 3) -***** test - % some angles - e = sym(1); - a = atan2(0, e); - assert (isequal (a, sym(0))) - a = atan2(e, 0); - assert (isequal (a, sym(pi)/2)) -***** test - % symbols can give numerical answer - syms x positive - a = atan2(0, x); - assert (isequal (a, sym(0))) - a = atan2(x, 0); - assert (isequal (a, sym(pi)/2)) - a = atan2(-x, 0); - assert (isequal (a, -sym(pi)/2)) -***** test - % matrices - x = sym([1 -2; 0 0]); - y = sym([0 0; 8 -3]); - a = atan2(y, x); - sp = sym(pi); - aex = [0 sp; sp/2 -sp/2]; - assert (isequal (a, aex)) -***** test - % round trip - syms x y - xd = -2; yd = -3; - f = atan2 (x, y); - A = atan2 (xd, yd); - h = function_handle (f); - B = h (xd, yd); - assert (A, B, -eps) -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@sym/sum.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sum.m -***** error sum (sym(1), 2, 3) -***** error sum (sym(1), 42) -***** shared x,y,z - syms x y z -***** assert (isequal (sum (x), x)) -***** assert (isequal (sum ([x y z]), x+y+z)) -***** assert (isequal (sum ([x; y; z]), x+y+z)) -***** assert (isequal (sum ([x y z], 1), [x y z])) -***** assert (isequal (sum ([x y z], 2), x+y+z)) -***** shared a,b - b = [1 2; 3 4]; a = sym(b); -***** assert (isequal (sum(a), sum(b))) -***** assert (isequal (sum(a,1), sum(b,1))) -***** assert (isequal (sum(a,2), sum(b,2))) -***** test - % weird inputs - a = sum('xx', sym(1)); - assert (isequal (a, sym('xx'))) -11 tests, 11 passed, 0 known failure, 0 skipped -[inst/@sym/has.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/has.m -***** shared A, x, y - syms x y - A = [sym(pi) 2*sym(pi); x*y x+y]; -***** assert (isequal (has(A, x), [false false; true true])); -***** assert (isequal (has(A, x+y), [false false; false true])); -***** assert (isequal (has(A, 2), [false true; false false])); -***** assert (isequal (has(A, sym(pi)), [true true; false false])); -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@sym/latex.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/latex.m -***** test - syms x - y = sin(x); - assert (strcmp (latex (y), '\sin{\left(x \right)}')) -***** assert (strcmp (latex (exp (sym('x'))), 'e^{x}')) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@sym/private_disp_name.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/private_disp_name.m -***** test - syms x - s = private_disp_name(x, 'x'); - assert (strcmp (s, 'x')) -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@sym/polylog.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/polylog.m -***** assert (isequal (polylog (sym('s'), 0), sym(0))) -***** assert (isequal (double (polylog (1, sym(-1))), -log(2))) -***** assert (isequal (double (polylog (0, sym(2))), -2)) -***** assert (isequal (double (polylog (-1, sym(2))), 2)) -***** assert (isequal (double (polylog (-2, sym(3))), -1.5)) -***** assert (isequal (double (polylog (-3, sym(2))), 26)) -***** assert (isequal (double (polylog (-4, sym(3))), -15)) -***** assert (isequal (double (polylog (1, sym(1)/2)), log(2))) -***** test - % round trip - syms s z - f = polylog (s, z); - h = function_handle (f, 'vars', [s z]); - A = h (1.1, 2.2); - B = polylog (1.1, 2.2); - assert (A, B) -9 tests, 9 passed, 0 known failure, 0 skipped -[inst/@sym/lt.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/lt.m -***** test - % simple - x = sym(1); y = sym(1); e = x < y; - assert (~logical (e)) - x = sym(1); y = sym(2); e = x < y; - assert (logical (e)) -***** test - % mix sym and double - x = sym(1); y = 1; e = x < y; - assert (~logical (e)) - x = sym(1); y = 2; e = x < y; - assert (logical (e)) - x = 1; y = sym(1); e = x < y; - assert (~logical (e)) - x = 1; y = sym(2); e = x < y; - assert (logical (e)) -***** test - % Type of the output is sym or logical? - % FIXME: in current version, they are sym - x = sym(1); y = sym(1); e1 = x < y; - x = sym(1); y = sym(2); e2 = x < y; - %assert (islogical (e1)) - %assert (islogical (e2)) - assert (isa (e1, 'sym')) - assert (isa (e2, 'sym')) -***** test - % ineq w/ symbols - syms x y - e = x < y; - assert (~islogical (e)) - assert (isa (e, 'sym')) -***** test - % array -- array - syms x - a = sym([1 3 3 2*x]); - b = sym([2 x 3 10]); - e = a < b; - assert (isa (e, 'sym')) - assert (logical (e(1))) - assert (isa (e(2), 'sym')) - assert (isequal (e(2), 3 < x)) - assert (~logical (e(3))) - assert (isa (e(4), 'sym')) - assert (isequal (e(4), 2*x < 10)) -***** test - % array -- scalar - syms x oo - a = sym([1 x oo]); - b = sym(3); - e = a < b; - assert (isa (e, 'sym')) - assert (logical (e(1))) - assert (isa (e(2), 'sym')) - assert (isequal (e(2), x < 3)) - assert (~logical (e(3))) -***** test - % scalar -- array - syms x oo - a = sym(1); - b = sym([2 x -oo]); - e = a < b; - assert (isa (e, 'sym')) - assert (logical (e(1))) - assert (isa (e(2), 'sym')) - assert (isequal (e(2), 1 < x)) - assert (~logical (e(3))) -***** test - % ineq w/ nan - syms x - snan = sym(nan); - e = x < snan; - assert (~logical (e)) - e = snan < x; - assert (~logical (e)) - b = [sym(0) x]; - e = b < snan; - assert (isequal (e, [false false])) -***** test - % oo - syms oo x - e = oo < x; - assert (isa (e, 'sym')) - assert (strcmp (strtrim (disp (e, 'flat')), 'oo < x')) -***** test - % sympy true matrix - a = sym([1 3 3]); - b = sym([2 4 1]); - e = a < b; - %assert (~isa (e, 'sym')) - %assert (islogical (e)) - assert (isequal (e, [true true false])) -***** test - % oo, finite real variables - syms oo - syms z real - assumeAlso(z, 'finite') - e = -oo < z; - assert (isequal (e, sym(true))) - e = z < oo; - assert (isequal (e, sym(true))) -***** test - % -oo, positive var (known failure w/ sympy 0.7.6.x) - syms oo - syms z positive - e = -oo < z; - assert (logical (e)) - assert (isequal (e, sym(true))) -***** test - % positive - syms z positive - e = -1 < z; - assert (isequal (e, sym(true))) -***** test - syms oo - z = sym('z', 'negative'); - e = z < oo; - assert (isequal (e, sym(true))) -14 tests, 14 passed, 0 known failure, 0 skipped -[inst/@sym/nextprime.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/nextprime.m -***** assert (isequal (nextprime(sym(2)), 3)); -***** assert (isequal (nextprime(sym(18)), 19)); -***** assert (isequal (nextprime(sym([1 2 3])), [2 3 5])); -***** assert (isequal (nextprime(sym([-1 0])), [2 2])); -***** test - % result is a sym - p = nextprime(sym(2)); - assert (isa (p, 'sym')) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/svd.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/svd.m -***** test - % basic - A = [1 2; 3 4]; - B = sym(A); - sd = svd(A); - s = svd(B); - s2 = double(s); - assert (norm(s2 - sd) <= 10*eps) -***** test - % scalars - syms x - syms y positive - a = sym(-10); - assert (isequal (svd(a), sym(10))) - assert (isequal (svd(x), sqrt(x*conj(x)))) - assert (isequal (svd(y), y)) -***** test - % matrix with symbols - syms x positive - A = [x+1 0; sym(0) 2*x+1]; - s = svd(A); - s2 = subs(s, x, 2); - assert (isequal (s2, [sym(5); 3])) -***** test - % matrix with symbols - syms x positive - A = [x+1 0; sym(0) 2*x+1]; - s = svd(A); - s2 = subs(s, x, 2); - assert (isequal (s2, [sym(5); 3])) -***** test - % matrix with symbols, nonneg sing values - syms x real - A = [x 0; 0 sym(-5)]; - s = svd(A); - assert (isequal (s, [abs(x); 5])) -5 tests, 5 passed, 0 known failure, 0 skipped -[inst/@sym/linspace.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/linspace.m -***** test - a = linspace(sym(3), 5, 5); - b = [sym(6) 7 8 9 10]/2; - assert (isequal (a, b)) -***** test - % non-integers - A = linspace(0, sym(pi), 10); - assert (length (A) == 10); - assert (isequal (A(6), 5*sym(pi)/9)); -***** test - % default argument for N - A = linspace(1, 100); - assert (length (A) == 100); -***** test - % special case for just N = 1 - A = linspace(sym(2), 3, 1); - assert (isequal (A, 3)) - A = linspace(sym(2), 3, 0); - assert (isequal (A, 3)) - A = linspace(sym(2), 3, sym(3)/2); - assert (isequal (A, 3)) -4 tests, 4 passed, 0 known failure, 0 skipped -[inst/cell2sym.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/cell2sym.m -***** test - A = {1 2 3; 4 5 6}; - B = [1 2 3; 4 5 6]; - assert (isequal (cell2sym(A), sym(B))) -***** test - A = {'a' 'b'; 'c' 10}; - B = [sym('a') sym('b'); sym('c') sym(10)]; - assert (isequal (cell2sym(A), B)) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/finiteset.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/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/dirac.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/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 dirac (1i) -***** assert (isa (dirac (single (0)), 'single')) -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/fibonacci.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/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/heaviside.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/heaviside.m -***** assert (heaviside (0) == 0.5) -***** assert (isnan (heaviside (nan))) -***** assert (isequal (heaviside ([-inf -eps 0 eps inf]), [0 0 0.5 1 1])) -***** assert (isequaln (heaviside ([-1 1 nan]), [0 1 nan])) -***** assert (heaviside (0, 1) == 1) -***** error heaviside (1i) -***** assert (isa (heaviside (single (0)), 'single')) -7 tests, 7 passed, 0 known failure, 0 skipped -[inst/laguerreL.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/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); + assert (logical(b(3,1) == a(3,1))) + assert (logical(b(1,3) == a(1,3))) + assert (logical(b(4,4) == a(4,4))) ***** 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); + % older array refs test: linear indices + assert (logical(b(1) == a(1))) + assert (logical(b(3) == a(3))) + assert (logical(b(13) == a(13))) ***** 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 laguerreL(1.5, 10) -***** error laguerreL([0 1], [1 2 3]) -***** error laguerreL([0 1], [1; 2]) + % older array refs test: end + assert (all(all(logical( b(end,1) == a(end,1) )))) + assert (all(all(logical( b(2,end) == a(2,end) )))) + assert (all(all(logical( b(end,end) == a(end,end) )))) + assert (all(all(logical( b(end-1,1) == a(end-1,1) )))) + assert (all(all(logical( b(2,end-1) == a(2,end-1) )))) + assert (all(all(logical( b(end-1,end-1) == a(end-1,end-1) )))) +***** shared ***** 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) + % older slicing tests + syms x + a = [1 2 3 4 5 6]; a = [a; 3*a; 5*a; 2*a; 4*a]; + b = sym(a); + assert (isequal( b(:,1), a(:,1) )) + assert (isequal( b(:,2), a(:,2) )) + assert (isequal( b(1,:), a(1,:) )) + assert (isequal( b(2,:), a(2,:) )) + assert (isequal( b(:,:), a(:,:) )) + assert (isequal( b(1:3,2), a(1:3,2) )) + assert (isequal( b(1:4,:), a(1:4,:) )) + assert (isequal( b(1:2:5,:), a(1:2:5,:) )) + assert (isequal( b(1:2:4,:), a(1:2:4,:) )) + assert (isequal( b(2:2:4,3), a(2:2:4,3) )) + assert (isequal( b(2:2:4,3), a(2:2:4,3) )) ***** test - % vectorized x - L = laguerreL (2, [5 6 7]); - Lex = [3.5 7 11.5]; - assert (L, Lex, eps) + % 2D arrays + b = [1:4]; b = [b; 3*b; 5*b]; + a = sym(b); + I = rand(size(b)) > 0.5; + assert (isequal (a(I), b(I))) + I = I(:); + assert (isequal (a(I), b(I))) + I = I'; + assert (isequal (a(I), b(I))) + I = logical(zeros(size(b))); + assert (isequal (a(I), b(I))) ***** test - L = laguerreL (0, [4 5]); - assert (L, [1 1], eps) + % 1D arrays, does right with despite warning + r = [1:6]; + ar = sym(r); + c = r'; + ac = sym(c); + Ir = rand(size(r)) > 0.5; + Ic = rand(size(c)) > 0.5; + assert (isequal (ar(Ir), r(Ir))) + assert (isequal (ac(Ic), c(Ic))) + assert (isequal (ar(Ic), r(Ic))) + assert (isequal (ac(Ir), c(Ir))) ***** test - % vector n - L = laguerreL ([0 1 2 3], [4 5 6 9]); - assert (L, [1 -4 7 -26], eps) + % rccross tests + B = [1 2 3 4; 5 6 7 9; 10 11 12 13]; + A = sym(B); + assert (isequal (A([1 3],[2 3]), B([1 3], [2 3]) )) + assert (isequal (A(1,[2 3]), B(1,[2 3]) )) + assert (isequal (A([1 2],4), B([1 2],4) )) + assert (isequal (A([2 1],[4 2]), B([2 1],[4 2]) )) + assert (isequal (A([],[]), B([],[]) )) +***** error + % issue #445 + A = sym([10 11]); + A(1.1) +***** error + % issue #445 + A = sym([10 11]); + A(sym(4)/3) +***** error + % issue #445 + A = sym([1 2; 3 4]); + A(1.1, 1) +***** error + % issue #445 + A = sym([1 2; 3 4]); + A(1, sym(4)/3) +***** error + A = sym([1 2; 3 4]); + A(5) +***** shared a, b + a = [1 2 3 5; 4 5 6 9; 7 5 3 2]; + b = sym (a); ***** 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/syms.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/syms.m + c = true; + assert (isequal (a(c), b(c))) + c = false; + assert (isequal (a(c), b(c))) ***** test - %% assumptions - syms x real - x2 = sym('x', 'real'); - assert (isequal (x, x2)) + c = [false true]; + assert (isequal (a(c), b(c))) + d = c | true; + assert (isequal (a(d), b(d))) + d = c & false; + assert (isequal (a(d), b(d))) ***** test - % assumptions and clearing them on a symbol - syms x real - assert (~isempty (assumptions (x))) - syms x - assert (isempty (assumptions (x))) + c = [false true false true; true false true false; false true false true]; + assert (isequal (a(c), b(c))) + d = c | true; + assert (isequal (a(d), b(d))) + d = c & false; + assert (isequal (a(d), b(d))) ***** test - % Note SMT would clear syms in existing expressions - syms x real - f = {x {2*x} cos(x/2)}; - assert (~isempty (assumptions (f))) - syms x - % but we do not: this would have to toggle for pure SMT compat - assert (~isempty (assumptions (f))) - % assert (isempty (assumptions (f))) -***** error - syms x clear -***** error - syms x positive y -***** error - % this sometimes catches typos or errors in assumption names - % (if you need careful checking, use sym not syms) - syms x positive evne -***** error - syms positive integer + c = [false true false true false]; + assert (isequal (a(c), b(c))) + d = c | true; + assert (isequal (a(d), b(d))) + d = c & false; + assert (isequal (a(d), b(d))) ***** test - % does not create a variable called positive - syms x positive integer - assert (logical(exist('x', 'var'))) - assert (~logical(exist('positive', 'var'))) + c = [false; true; false; true; false]; + assert (isequal (a(c), b(c))) + d = c | true; + assert (isequal (a(d), b(d))) + d = c & false; + assert (isequal (a(d), b(d))) ***** test - % Issue #885 - syms S(x) I(x) O(x) + c = [false true; false true; true false]; + assert (isequal (a(c), b(c))) + d = c | true; + assert (isequal (a(d), b(d))) + d = c & false; + assert (isequal (a(d), b(d))) +***** shared ***** test - % Issue #290 - syms FF(x) - syms ff(x) - syms Eq(x) + % Orientation of empty results of logical indexing on row or column vectors + r = [1:6]; + c = r'; + ar = sym(r); + ac = sym(c); + assert (isequal (ar(false), r(false))) + assert (isequal (ac(false), c(false))) + assert (isequal (ar(false (1, 6)), r(false (1, 6)))) + assert (isequal (ac(false (1, 6)), c(false (1, 6)))) + assert (isequal (ar(false (6, 1)), r(false (6, 1)))) + assert (isequal (ac(false (6, 1)), c(false (6, 1)))) +50 tests, 50 passed, 0 known failure, 0 skipped +[inst/@sym/mrdivide.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/mrdivide.m ***** test - % Issue #290 - syms beta(x) + % scalar + syms x + assert (isa( x/x, 'sym')) + assert (isequal( x/x, sym(1))) + assert (isa( 2/x, 'sym')) + assert (isa( x/2, 'sym')) ***** test - syms x real - syms f(x) - assert (~ isempty (assumptions (x))) + % matrix / scalar + D = 2*[0 1; 2 3]; + A = sym(D); + assert (isequal ( A/2 , D/2 )) + assert (isequal ( A/sym(2) , D/2 )) ***** test - syms x real - f(x) = symfun(sym('f(x)'), x); - assert (~ isempty (assumptions (x))) - assert (~ isempty (assumptions (argnames (f)))) -13 tests, 13 passed, 0 known failure, 0 skipped -[inst/poly2sym.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/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 )) + % I/A: either invert A or leave unevaluated: not bothered which + A = sym([1 2; 3 4]); + B = sym(eye(2)) / A; + assert (isequal (B, inv(A)) || strncmpi (sympy (B), 'MatPow', 6)) +***** xtest + % immutable test, upstream: TODO + A = sym([1 2; 3 4]); + B = sym('ImmutableDenseMatrix([[Integer(1), Integer(2)], [Integer(3), Integer(4)]])'); + assert (isequal (A/A, B/B)) ***** test - % mixed cell array with doubles and syms - assert (isequal (poly2sym ({2.0 sym(3) int64(4)}), 2*x^2 + 3*x + 4)) + % A = C/B is C = A*B + A = sym([1 2; 3 4]); + B = sym([1 3; 4 8]); + C = A*B; + A2 = C / B; + assert (isequal (A, A2)) ***** 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 -[inst/catalan.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/catalan.m -***** error catalan (sym(1)) -***** assert (double (catalan ()) > 0.915965594177) -***** assert (double (catalan ()) < 0.915965594178) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/lambertw.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/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) + A = [1 2; 3 4]; + B = A / A; + % assert (isequal (B, sym(eye(2)) + assert (isequal (B(1,1), 1)) + assert (isequal (B(2,2), 1)) + assert (isequal (B(2,1), 0)) + assert (isequal (B(1,2), 0)) ***** test - x = [1 2 3 pi 10 100 1000 12345]; - W = lambertw (x); - assert (W.*exp (W), x, -3*eps) + A = sym([5 6]); + B = sym([1 2; 3 4]); + C = A*B; + A2 = C / B; + assert (isequal (A, A2)) +7 tests, 7 passed, 0 known failure, 0 skipped +[inst/@sym/potential.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/potential.m +***** error potential (sym(1), 2, 3, 4) +***** shared x,y,z + syms x y z ***** 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) + % 1D + f = 3*x^2; + F = x^3; + assert (isequal (potential(f), F)) + assert (isequal (potential(f, x), F)) + assert (isequal (potential(f, x, 0), F)) + assert (isequal (potential(f, x, 2), F - 8)) ***** test - % input shape preserved - x = [0 1; 2 3]; - b = x; - W = lambertw (b, x); - assert (W.*exp (W), x, -10*eps) + F = x*exp(y) + (z-1)^2; + f = gradient(F); + G = potential(f, [x;y;z], [0;1;1]); + assert (isAlways (G == F)) ***** test - % input shape preserved - x = [0 1; 2 3]; - b = 0; - W = lambertw (b, x); - assert (W.*exp (W), x, -10*eps) + F = x*exp(y); + f = gradient(F); + G = potential(f); + assert (isAlways (G == F)) ***** 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))) + % 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/sort.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sort.m +***** error sort (sym(1), 2) ***** test - % limiting behaviour as z large - k = 3; - A = lambertw (k, 1e100); - assert (abs (imag (A) - 2*pi*k) < 0.1) + f = [sym(1), sym(0)]; + expected = sym([0, 1]); + assert (isequal (sort(f), expected)) ***** 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) + f = [sym(1)]; + expected = sym(1); + assert (isequal (sort(f), expected)) ***** 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) + f = [sym(3), sym(2), sym(6)]; + s = sort(f); + expected_s = sym([2, 3, 6]); + assert (isequal (s, expected_s)) ***** 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) + f = [sym(pi), sin(sym(2)), sqrt(sym(6))]; + s = sort(f); + expected_s = sym([sin(sym(2)), sqrt(sym(6)), sym(pi)]); + assert (isequal (s, expected_s)) ***** test - % infinities and nan - A = lambertw ([inf exp(1) -inf nan]); - B = [inf 1 inf + pi*1i nan]; - assert (isequaln (A, B)) + f = [sym(1), sym(2); sym(2), sym(pi); sym(pi), sym(1)]; + s = sort(f); + expected_s = ([sym(1), sym(1); sym(2), sym(2); sym(pi), sym(pi)]); + assert (isequal (s, expected_s)) +***** assert (isequal (sort(sym([])), sym([]))) +***** error sort([sym('x') 1]) ***** 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)) + % but with assumptions, symbols can be sorted + p = sym('p', 'positive'); + n = sym('n', 'negative'); + expected_s = [n p]; + s = sort ([p n]); + assert (isequal (s, expected_s)) +9 tests, 9 passed, 0 known failure, 0 skipped +[inst/@sym/isallconstant.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isallconstant.m +***** assert (isallconstant([sym(1) 2 3])) ***** 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)) + syms x + assert (~isallconstant([sym(1) x 3])) ***** 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)) + syms x + assert (~isallconstant([sym(1) x; sym(2) 3])) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/cumprod.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/cumprod.m +***** shared x, y + x = sym ('x'); + y = sym ('y'); +***** error cumprod (x, 1, 2) +***** assert (isequal (cumprod ([-x; -2*x; -3*x]), [-x; 2*x^2; -6*x^3])) +***** assert (isequal (expand (cumprod ([x + i, x - i])), [x + i, x^2 + 1])) +***** assert (isequal (cumprod ([1, x; y, 2], 1), [1, x; y, 2*x] )) +***** assert (isequal (cumprod ([1, x; y, 2], 2), [1, x; y, 2*y] )) +***** test cumprod ([x, x], [2, 1]); # ensure behaves like builtin cumprod +***** test cumprod ([x, x], [1, -2]); # ensure behaves like builtin cumprod +***** error cumprod (x, []) +***** error cumprod (x, {1}) +***** error cumprod (x, struct('a', 1)) +***** error cumprod (x, x) +***** error cumprod (x, 0) +***** error cumprod (x, -1) +13 tests, 13 passed, 0 known failure, 0 skipped +[inst/@sym/acsch.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/acsch.m +***** error acsch (sym(1), 2) +***** assert (isequaln (acsch (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); ***** 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)) + f1 = acsch(x); + f2 = acsch(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** 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/pycall_sympy__.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/pycall_sympy__.m + D = [d d; d d]; + A = [x x; x x]; + f1 = acsch(A); + f2 = acsch(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test - % general test - x = 10; y = 6; - cmd = '(x,y) = _ins; return (x+y,x-y)'; - [a,b] = pycall_sympy__ (cmd, x, y); - assert (a == x + y && b == x - y) + % round trip + y = sym('y'); + A = acsch (d); + f = acsch (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/subs.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/subs.m +***** error subs (sym(1), 2, 3, 4) +***** shared x,y,t,f + syms x y t + f = x*y; ***** test - % bool - assert (pycall_sympy__ ('return True,')) - assert (~pycall_sympy__ ('return False,')) + assert( isequal( subs(f, x, y), y^2 )) + assert( isequal( subs(f, y, sin(x)), x*sin(x) )) + assert( isequal( subs(f, x, 16), 16*y )) ***** test - % float - assert (abs(pycall_sympy__ ('return 1.0/3,') - 1/3) < 1e-15) + % multiple subs w/ cells + assert( isequal( subs(f, {x}, {t}), y*t )) + assert( isequal( subs(f, {x y}, {t t}), t*t )) + assert( isequal( subs(f, {x y}, {t 16}), 16*t )) + assert( isequal( subs(f, {x y}, {16 t}), 16*t )) + assert( isequal( subs(f, {x y}, {2 16}), 32 )) ***** test - % int - r = pycall_sympy__ ('return 123456'); - assert (r == 123456) - assert (isinteger (r)) + % multiple subs w/ vectors + assert( isequal( subs(f, [x y], [t t]), t*t )) + assert( isequal( subs(f, [x y], [t 16]), 16*t )) + assert( isequal( subs(f, [x y], [2 16]), 32 )) ***** test - % string - x = 'octave'; - cmd = 's = _ins[0]; return s.capitalize(),'; - y = pycall_sympy__ (cmd, x); - assert (strcmp(y, 'Octave')) + % anything you can think of + assert( isequal( subs(f, [x y], {t t}), t*t )) + assert( isequal( subs(f, {x y}, [t t]), t*t )) + assert( isequal( subs(f, {x; y}, [t; t]), t*t )) ***** test - % string with escaped newlines, comes back as escaped newlines - x = 'a string\nbroke off\nmy guitar\n'; - y = pycall_sympy__ ('return _ins', x); - assert (strcmp(y, x)) + % sub in doubles gives sym (matches SMT 2013b) + % FIXME: but see + % http://www.mathworks.co.uk/help/symbolic/gradient.html + assert( isequal( subs(f, {x y}, {2 pi}), 2*sym(pi) )) + assert( ~isa(subs(f, {x y}, {2 pi}), 'double')) + assert( isa(subs(f, {x y}, {2 pi}), 'sym')) + assert( isa(subs(f, {x y}, {2 sym(pi)}), 'sym')) + assert( isa(subs(f, {x y}, {sym(2) sym(pi)}), 'sym')) +***** shared x,y,t,f,F + syms x y t + f = sin(x)*y; + F = [f; 2*f]; ***** test - % string with actual newlines, comes back as actual newlines - x = sprintf('a string\nbroke off\nmy guitar\n'); - y = pycall_sympy__ ('return _ins', x); - y2 = strrep(y, sprintf('\n'), sprintf('\r\n')); % windows - assert (strcmp(x, y) || strcmp(x, y2)) + % need the simultaneous=True flag in SymPy (matches SMT 2013b) + assert( isequal( subs(f, [x t], [t 6]), y*sin(t) )) + assert( isequal( subs(F, [x t], [t 6]), [y*sin(t); 2*y*sin(t)] )) ***** test - % cmd string with newlines, works with cell - y = pycall_sympy__ ('return "string\nbroke",'); - y2 = sprintf('string\nbroke'); - y3 = strrep(y2, sprintf('\n'), sprintf('\r\n')); % windows - assert (strcmp(y, y2) || strcmp(y, y3)) + % swap x and y (also needs simultaneous=True + assert( isequal( subs(f, [x y], [y x]), x*sin(y) )) ***** test - % string with XML escapes - x = '<> >< <<>>'; - y = pycall_sympy__ ('return _ins', x); - assert (strcmp(y, x)) - x = '&'; - y = pycall_sympy__ ('return _ins', x); - assert (strcmp(y, x)) + % but of course both x and y to t still works + assert( isequal( subs(f, [x y], [t t]), t*sin(t) )) +***** shared ***** test - % strings with double quotes - x = 'a\"b\"c'; - y = pycall_sympy__ ('return _ins', x); - assert (strcmp(y, x)) - x = '\"'; - y = pycall_sympy__ ('return _ins', x); - assert (strcmp(y, x)) + % Issue #10, subbing matrices in for scalars + syms y + a = sym([1 2; 3 4]); + f = sin(y); + g = subs(f, y, a); + assert (isequal (g, sin(a))) ***** test - % cmd has double quotes, these must be escaped by user - % (of course: she is writing python code) - expy = 'a"b"c'; - y = pycall_sympy__ ('return "a\"b\"c",'); - assert (strcmp(y, expy)) + % Issue #10, subbing matrices in for scalars + syms y + a = sym([1 2]); + g = subs(sin(y), {y}, {a}); + assert (isequal (g, sin(a))) ***** test - % strings with quotes - x = 'a''b'; % this is a single quote - y = pycall_sympy__ ('return _ins', x); - assert (strcmp(y, x)) + % Issue #10, subbing matrices in for scalars + syms y + a = sym([1; 2]); + g = subs(sin(y), {y}, a); + assert (isequal (g, sin(a))) ***** test - % strings with quotes - x = '\"a''b\"c''\"d'; - y = pycall_sympy__ ('return _ins[0]', x); - assert (strcmp(y, x)) + % Issue #10, subbing matrices in for scalars + syms y + a = [10 20 30]; + f = 2*y; + g = subs(f, y, a); + assert (isequal (g, 2*a)) + assert (isa (g, 'sym')) ***** test - % strings with quotes - expy = '"a''b"c''"d'; - y = pycall_sympy__ ('s = "\"a''b\"c''\"d"; return s'); - assert (strcmp(y, expy)) + % Issue #10, sub matrices in for two scalars + syms x y + a = [10 20 30]; + f = x^2*y; + g = subs(f, {x y}, {a a+1}); + h = a.^2.*(a+1); + assert (isequal (g, h)) ***** test - % strings with printf escapes - x = '% %% %%% %%%% %s %g %%s'; - y = pycall_sympy__ ('return _ins', x); - assert (strcmp(y, x)) + % Issue #10, sub matrices in for two scalars + syms x y z + a = [10 20 30]; + f = x^2*y; + g = subs(f, {x y}, {a z}); + h = a.^2*z; + assert (isequal (g, h)) + g = subs(f, {x y}, {a 6}); + h = a.^2*6; + assert (isequal (g, h)) +***** error + syms x y + a = [10 20 30]; + f = x^2*y; + g = subs(f, {x y}, {[10 20 30] [10 20]}); ***** test - % cmd with printf escapes - x = '% %% %%% %%%% %s %g %%s'; - y = pycall_sympy__ (['return "' x '",']); - assert (strcmp(y, x)) + % two inputs + syms x y + assert (isequal (subs (2*x, 6), sym(12))) + assert (isequal (subs (2*x*y^2, 6), 12*y^2)) + assert (isequal (subs (2*y, 6), sym(12))) + assert (isequal (subs (sym(2), 6), sym(2))) ***** test - % cmd w/ backslash and \n must be escaped by user - expy = 'a\b\\c\nd\'; - y = pycall_sympy__ ('return "a\\b\\\\c\\nd\\",'); - assert (strcmp(y, expy)) + % only two inputs, vector + syms x + assert (isequal (subs (2*x, [3 5]), sym([6 10]))) ***** test - % slashes - x = '/\\ // \\\\ \\/\\/\\'; - z = '/\ // \\ \/\/\'; - y = pycall_sympy__ ('return _ins', x); - assert (strcmp(y, x)) + % SMT compat, subbing in vec/mat for nonexist x + syms x y z + % you might think this would be y: + assert (~ isequal (subs (y, x, [1 2]), y)) + % but it gives two y's: + assert (isequal (subs (y, x, [1 2]), [y y])) + assert (isequal (subs (sym(42), [3 5]), sym([42 42]))) + assert (isequal (subs (sym(42), x, []), sym([]))) + assert (isequal (subs (y, {x y}, {[1 2; 3 4], 6}), sym([6 6; 6 6]))) + assert (isequal (subs (y, {x z}, {[1 2; 3 4], 6}), [y y; y y])) ***** test - % slashes - z = '/\ // \\ \/\/\'; - y = pycall_sympy__ ('return "/\\ // \\\\ \\/\\/\\"'); - assert (strcmp(y, z)) + syms x y + assert (isequal (subs (sym(42), x, y), sym(42))) + assert (isequal (subs (sym(42), y), sym(42))) + assert (isequal (subs (sym(42)), sym(42))) ***** test - % strings with special chars - x = '!@#$^&* you!'; - y = pycall_sympy__ ('return _ins', x); - assert (strcmp(y, x)) - x = '~-_=+[{]}|;:,.?'; - y = pycall_sympy__ ('return _ins', x); - assert (strcmp(y, x)) -***** xtest - % string with backtick trouble for system -c (sysoneline) - x = '`'; - y = pycall_sympy__ ('return _ins', x); - assert (strcmp(y, x)) + % empty lists + assert (isequal (subs (sym(42), {}, {}), sym(42))) + assert (isequal (subs (42, sym([]), sym([])), sym(42))) ***** test - % unicode - s1 = '我爱你'; - cmd = 'return u"\u6211\u7231\u4f60",'; - s2 = pycall_sympy__ (cmd); - assert (strcmp (s1, s2)) + syms x y + f = x*y; + x = 6; y = 7; + g = subs (f); + assert (isequal (g, sym (42))) + assert (isa (g, 'sym')) ***** test - % unicode with \x - s1 = '我'; - cmd = 'return b"\xe6\x88\x91".decode("utf-8")'; - s2 = pycall_sympy__ (cmd); - assert (strcmp (s1, s2)) + syms x y + f = x*y; + x = 6; + g = subs (f); + assert (isequal (g, 6*y)) ***** test - % unicode with \x and some escaped backslashes - s1 = '\我\'; - cmd = 'return b"\\\xe6\x88\x91\\".decode("utf-8")'; - s2 = pycall_sympy__ (cmd); - assert (strcmp (s1, s2)) -***** xtest - % unicode passthru - s = '我爱你'; - s2 = pycall_sympy__ ('return _ins', s); - assert (strcmp (s, s2)) - s = '我爱你<>\&//\#%% %\我'; - s2 = pycall_sympy__ ('return _ins', s); - assert (strcmp (s, s2)) -***** xtest - % unicode w/ slashes, escapes - s = '我<>\&//\#%% %\我'; - s2 = pycall_sympy__ ('return "我<>\\&//\\#%% %\\我"'); - assert (strcmp (s, s2)) + syms x y + f = x*y; + xsave = x; + x = 6; + g = subs (f); + assert (isequal (g, 6*y)) + assert (isequal (f, xsave*y)) ***** test - % list, tuple - assert (isequal (pycall_sympy__ ('return [1,2,3],'), {1, 2, 3})) - assert (isequal (pycall_sympy__ ('return (4,5),'), {4, 5})) - assert (isequal (pycall_sympy__ ('return (6,),'), {6,})) - assert (isequal (pycall_sympy__ ('return [],'), {})) + syms a x y + f = a*x*y; + a = 6; + clear x + g = subs (f); + syms x + assert (isequal (g, 6*x*y)) +25 tests, 25 passed, 0 known failure, 0 skipped +[inst/@sym/log.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/log.m +***** error log (sym(1), 2) +***** assert (isequaln (log (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); ***** test - % dict - cmd = 'd = dict(); d["a"] = 6; d["b"] = 10; return d,'; - d = pycall_sympy__ (cmd); - assert (d.a == 6 && d.b == 10) + f1 = log(x); + f2 = log(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - r = pycall_sympy__ ('return 6'); - assert (isequal (r, 6)) + D = [d d; d d]; + A = [x x; x x]; + f1 = log(A); + f2 = log(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test - r = pycall_sympy__ ('return "Hi"'); - assert (strcmp (r, 'Hi')) + % round trip + y = sym('y'); + A = log (d); + f = log (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/find.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/find.m +***** error find (sym (1), 2, 3, 4) +***** error [x, y, z, w] = find (sym (1)) ***** test - % blank lines, lines with spaces - a = pycall_sympy__ ({ '', '', ' ', 'return 6', ' ', ''}); - assert (isequal (a, 6)) + syms x y positive + assert (isequal (find ([0 x 0 y]), [2 4])) + assert (isequal (find ([0 x 0 y], 1), 2)) + assert (isequal (find ([0 x 0 y], 1, 'first'), 2)) + assert (isequal (find ([0 x 0 y], 1, 'last'), 4)) + assert (isequal (find ([0 x 0 y], 2, 'last'), [2 4])) ***** test - % blank lines, strange comment lines - cmd = {'a = 1', '', '#', '', '# ', ' #', 'a = a + 2', ' #', 'return a'}; - a = pycall_sympy__ (cmd); - assert (isequal (a, 3)) + % its enough that it could be non-zero, does not have to be + syms x y + assert (isequal (find ([0 x+y]), 2)) ***** test - % return empty string (was https://bugs.python.org/issue25270) - assert (isempty (pycall_sympy__ ('return ""'))) + % false should not be found + syms x y + assert (isequal (find ([x==x x==y]), 1)) + assert (isequal (find ([x==y]), [])) ***** test - % return nothing (via an empty list) - % note distinct from 'return [],' - pycall_sympy__ ('return []') + % and/or should be treated as boolean + syms x y + assert (isequal (find ([or(x==y, x==2*y) x==y x==x]), 3)) ***** test - % return nothing (because no return command) - pycall_sympy__ ('dummy = 1') + % None + none = pycall_sympy__ ('return None'); + assert (isequal (find ([sym(0) none sym(1)]), 3)) + syms x y + assert (isequal (find ([x==y none x==x]), 3)) ***** test - % return nothing (because no command) - pycall_sympy__ ('') + % two output + syms x y + A = [x 0 0; x+y 5 0]; + [i, j] = find (A); + assert (isequal (i, [1; 2; 2])) + assert (isequal (j, [1; 1; 2])) ***** test - % return nothing (because no command) - pycall_sympy__ ({}) -***** error - % python exception while passing variables to python - % This tests the "INTERNAL_PYTHON_ERROR" path. - % FIXME: this is a very specialized test, relies on internal octsympy - % implementation details, and may need to be adjusted for changes. - disp('') - disp('**********************************************************************') - disp('') - disp(' Some deliberate AttributeError and ValueError may appear next') - disp('') - disp('v v v v v v v v v v v v v v v v v v v v v v v v') - b = sym([], 'S.This_is_supposed_to_make_an_exception', [1 1], 'Test', 'Test', 'Test'); - c = b + 1; - -********************************************************************** - - Some deliberate AttributeError and ValueError may appear next - -v v v v v v v v v v v v v v v v v v v v v v v v -Traceback (most recent call last): - File "", line 4, in - File "/usr/lib/python3/dist-packages/sympy/core/singleton.py", line 118, in __getattr__ - raise AttributeError( -AttributeError: Attribute 'This_is_supposed_to_make_an_exception' was not installed on SymPy registry S + % three output + syms x y + A = [x 0 0; x+y 5 0]; + [i, j, v] = find (A); + assert (isequal (i, [1; 2; 2])) + assert (isequal (j, [1; 1; 2])) + assert (isequal (v, [x; x+y; sym(5)])) +9 tests, 9 passed, 0 known failure, 0 skipped +[inst/@sym/dsolve.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/dsolve.m +***** error dsolve (1, sym('x')) ***** test - % ...and after the above test, the pipe should still work - a = pycall_sympy__ ('return _ins[0]*2', 3); - assert (isequal (a, 6)) + syms y(x) + de = diff(y, 2) - 4*y == 0; + f = dsolve(de); + syms C1 C2 + g1 = C1*exp(-2*x) + C2*exp(2*x); + g2 = C2*exp(-2*x) + C1*exp(2*x); + assert (isequal (f, g1) || isequal (f, g2)) ***** test - % This command does not fail with native interface and '@pyobject' - s = warning ('off', 'OctSymPy:pythonic_no_convert'); + % Not enough initial conditions + syms y(x) C1 + de = diff(y, 2) + 4*y == 0; + g = 3*cos(2*x) + C1*sin(2*x); try - q = pycall_sympy__ ({'return type(int)'}); + f = dsolve(de, y(0) == 3); + waserr = false; catch - msg = lasterror.message; - assert (~ isempty (regexp (msg, '.*does not know how to.*'))) + waserr = true; + expectederr = regexp (lasterr (), 'Perhaps.*under-specified'); + f = 42; end - warning (s) - disp('^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^') - disp(' End of deliberate errors!') - disp(' You should see "46/46" or "Passes 46 out of 46 tests" below') - disp('**********************************************************************') - % ...and after the above test, the pipe should still work - a = pycall_sympy__ ('return _ins[0]*2', 3); - assert (isequal (a, 6)) -Traceback (most recent call last): - File "", line 2, in - File "", line 12, in octoutput_drv - File "", line 96, in octoutput -ValueError: octoutput does not know how to export type -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - End of deliberate errors! - You should see "46/46" or "Passes 46 out of 46 tests" below -********************************************************************** + assert ((waserr && expectederr) || isequal (f, g)) ***** test - % complex input - [A, B] = pycall_sympy__ ('z = 2*_ins[0]; return (z.real,z.imag)', 3+4i); - assert (A, 6) - assert (B, 8) + % Solution in implicit form + syms y(x) C1 + de = (2*x*y(x) - exp(-2*y(x)))*diff(y(x), x) + y(x) == 0; + sol = dsolve (de); + eqn = x*exp(2*y(x)) - log(y(x)) == C1; + % could differ by signs + sol = lhs (sol) - rhs (sol); + eqn = lhs (eqn) - rhs (eqn); + sol2 = subs (sol, C1, -C1); + assert (isequal (sol, eqn) || isequal (sol2, eqn)) ***** test - % complex output - z = pycall_sympy__ ('return 3+2j'); - assert (z, 3+2i) -***** error - s = char ('abc', 'defgh', '12345'); - r = pycall_sympy__ ('return _ins[0]', s); + % Compute solution and classification + syms y(x) C1 + de = (2*x*y(x) - exp(-2*y(x)))*diff(y(x), x) + y(x) == 0; + [sol, classy] = dsolve (de); + assert (any (strcmp (classy, '1st_exact'))) ***** test - r = pycall_sympy__ ('return len(_ins[0])', ''); - assert (r == 0) + % initial conditions (first order ode) + syms y(x) + de = diff(y, x) + 4*y == 0; + f = dsolve(de, y(0) == 3); + g = 3*exp(-4*x); + assert (isequal (f, g)) ***** test - % ensure the 0x0 matrix in octave gets mapped to the empty list in python - % @sym/subsasgn currently replies on this behaviour - assert (pycall_sympy__ ('return _ins[0] == []', [])); + % initial conditions (second order ode) + syms y(x) + de = diff(y, 2) + 4*y == 0; + f = dsolve(de, y(0) == 3, subs(diff(y,x),x,0)==0); + g = 3*cos(2*x); + assert (isequal (f, g)) ***** test - % ensure the empty string gets mapped to the empty string in python - assert (pycall_sympy__ ('return _ins[0] == ""', '')); -46 tests, 46 passed, 0 known failure, 0 skipped -[inst/assumptions.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/assumptions.m + % Dirichlet boundary conditions (second order ode) + syms y(x) + de = diff(y, 2) + 4*y == 0; + f = dsolve(de, y(0) == 2, y(1) == 0); + g = -2*sin(2*x)/tan(sym('2'))+2*cos(2*x); + assert (isequal (simplify (f - g), 0)) ***** test - syms x - assert(isempty(assumptions(x))) + % Neumann boundary conditions (second order ode) + syms y(x) + de = diff(y, 2) + 4*y == 0; + f = dsolve(de, subs(diff(y,x),x,0)==1, subs(diff(y,x),x,1)==0); + g = sin(2*x)/2+cos(2*x)/(2*tan(sym('2'))); + assert (isequal (simplify (f - g), 0)) ***** test - x = sym('x', 'positive'); - a = assumptions(x); - assert(~isempty(strfind(a{1}, 'positive'))) + % Dirichlet-Neumann boundary conditions (second order ode) + syms y(x) + de = diff(y, 2) + 4*y == 0; + f = dsolve(de, y(0) == 3, subs(diff(y,x),x,1)==0); + g = 3*sin(2*x)*tan(sym('2'))+3*cos(2*x); + assert (isequal (simplify (f - g), 0)) ***** test - syms x - assert(isempty(assumptions(x))) + % System of ODEs gives struct, Issue #1003. + syms x(t) y(t) + ode1 = diff(x(t),t) == 2*y(t); + ode2 = diff(y(t),t) == 2*x(t); + soln = dsolve([ode1, ode2]); + assert (isstruct (soln)) + assert (numfields (soln) == 2) + assert (isequal (sort (fieldnames (soln)), {'x'; 'y'})) ***** test - clear variables % for matlab test script - syms x positive - assert(~isempty(assumptions())) - clear x - assert(isempty(assumptions())) + % System of ODEs + syms x(t) y(t) C1 C2 + ode1 = diff(x(t),t) == 2*y(t); + ode2 = diff(y(t),t) == 2*x(t); + soln = dsolve([ode1, ode2]); + soln = [soln.x, soln.y]; + g1 = [C1*exp(-2*t) + C2*exp(2*t), -C1*exp(-2*t) + C2*exp(2*t)]; + g2 = [C1*exp(2*t) + C2*exp(-2*t), C1*exp(2*t) - C2*exp(-2*t)]; + g3 = [-C1*exp(-2*t) + C2*exp(2*t), C1*exp(-2*t) + C2*exp(2*t)]; + g4 = [C1*exp(2*t) - C2*exp(-2*t), C1*exp(2*t) + C2*exp(-2*t)]; + % old SymPy <= 1.5.1 had some extra twos + g5 = [2*C1*exp(-2*t) + 2*C2*exp(2*t), -2*C1*exp(-2*t) + 2*C2*exp(2*t)]; + g6 = [2*C1*exp(2*t) + 2*C2*exp(-2*t), 2*C1*exp(2*t) - 2*C2*exp(-2*t)]; + assert (isequal (soln, g1) || isequal (soln, g2) || ... + isequal (soln, g3) || isequal (soln, g4) || ... + isequal (soln, g5) || isequal (soln, g6)) ***** test - % make sure we have at least these possible assumptions - A = {'real' 'positive' 'negative' 'integer' 'even' 'odd' 'rational'}; - B = assumptions('possible'); - assert (isempty (setdiff(A, B))) + % System of ODEs (initial-value problem) + syms x(t) y(t) + ode_1=diff(x(t),t) == 2*y(t); + ode_2=diff(y(t),t) == 2*x(t); + sol_ivp=dsolve([ode_1,ode_2],x(0)==1,y(0)==0); + g_ivp=[exp(-2*t)/2+exp(2*t)/2,-exp(-2*t)/2+exp(2*t)/2]; + assert (isequal ([sol_ivp.x, sol_ivp.y], g_ivp)) ***** test - A = assumptions('possible'); - for i = 1:length(A) - x = sym('x', A{i}); - a = assumptions(x); - assert(strcmp(a{1}, ['x: ' A{i}] )) - s1 = sympy (x); - s2 = ['Symbol(''x'', ' A{i} '=True)']; - assert (strcmp (s1, s2)) - end + syms y(x) + de = diff(y, 2) + 4*y == 0; + f = dsolve(de, y(0) == 0, y(sym(pi)/4) == 1); + g = sin(2*x); + assert (isequal (f, g)) ***** test - syms x positive - syms y real - syms z - f = x*y*z; - a = assumptions(f); - assert(length(a) == 2) - assert(~isempty(strfind(a{1}, 'positive'))) - assert(~isempty(strfind(a{2}, 'real'))) + % Nonlinear example + syms y(x) C1 + e = diff(y, x) == y^2; + g = -1 / (C1 + x); + soln = dsolve(e); + assert (isequal (soln, g)) ***** test - % dict output - syms x positive - syms y real - syms z - f = x*y*z; - [v, d] = assumptions(f, 'dict'); - assert(length(v) == 2) - assert(iscell(v)) - assert(isa(v{1}, 'sym')) - assert(isa(v{2}, 'sym')) - assert(length(d) == 2) - assert(iscell(d)) - assert(isstruct(d{1})) - assert(isstruct(d{2})) + % Nonlinear example with initial condition + syms y(x) + e = diff(y, x) == y^2; + g = -1 / (x - 1); + soln = dsolve(e, y(0) == 1); + assert (isequal (soln, g)) ***** test - %% assumptions on just the vars in an expression - clear variables % for matlab test script - syms x y positive - f = 2*x; - assert(length(assumptions(f))==1) - assert(length(assumptions())==2) + % forcing, Issue #183, broken in older sympy + if (pycall_sympy__ ('return Version(spver) >= Version("1.7.1")')) + syms x(t) y(t) + ode1 = diff(x) == x + sin(t) + 2; + ode2 = diff(y) == y - t - 3; + soln = dsolve([ode1 ode2], x(0) == 1, y(0) == 2); + X = soln.x; + Y = soln.y; + assert (isequal (diff(X) - (X + sin(t) + 2), 0)) + assert (isequal (diff(Y) - (Y - t - 3), 0)) + end ***** test - %% assumptions in cell/struct - clear variables % for matlab test script - syms x y z w positive - f = {2*x [1 2 y] {1, {z}}}; - assert(length(assumptions())==4) - assert(length(assumptions(f))==3) - clear x y z w - assert(length(assumptions())==3) - assert(length(assumptions(f))==3) + syms f(x) a b + de = diff(f, x) == 4*f; + s = dsolve(de, f(a) == b); + assert (isequal (subs(s, x, a), b)) ***** test - % multiple assumptions - n = sym('n', 'negative', 'even'); - assert (logical (n < 0)) - assert (~(logical (n > 0))) - assert (~(logical (n == -1))) + % array of ICs + syms x(t) y(t) + ode_1 = diff (x(t), t) == 2*y(t); + ode_2 = diff (y(t), t) == 2*x(t); + sol = dsolve([ode_1, ode_2], [x(0)==1 y(0)==0]); + g = [exp(-2*t)/2+exp(2*t)/2, -exp(-2*t)/2+exp(2*t)/2]; + assert (isequal ([sol.x, sol.y], g)) ***** test - % multiple assumptions: eqn neither true nor false - n = sym('n', 'negative', 'even'); - assert (~isequal (n, sym(true)) && ~isequal (n, sym(false))) + % cell-array of ICs or ODEs, but not both + % Note: to support both we'd need a wrapper outside of @sym + syms x(t) y(t) + ode_1 = diff (x(t), t) == 2*y(t); + ode_2 = diff (y(t), t) == 2*x(t); + sol = dsolve([ode_1, ode_2], {x(0)==1 y(0)==0}); + g = [exp(-2*t)/2+exp(2*t)/2, -exp(-2*t)/2+exp(2*t)/2]; + assert (isequal ([sol.x, sol.y], g)) + sol = dsolve({ode_1, ode_2}, [x(0)==1 y(0)==0]); + g = [exp(-2*t)/2+exp(2*t)/2, -exp(-2*t)/2+exp(2*t)/2]; + assert (isequal ([sol.x, sol.y], g)) ***** test - %% TODO: rewrite later with https://github.com/gnu-octave/symbolic/issues/622 - a = pycall_sympy__ ('return Symbol("a", real=False)'); - assert (strcmp (assumptions (a), {'a: ~real'})) -13 tests, 13 passed, 0 known failure, 0 skipped -[inst/vpasolve.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/vpasolve.m + % array of ICs, Issue #1040. + if (pycall_sympy__ ('return Version(spver) >= Version("1.7.1")')) + syms x(t) y(t) z(t) + syms x_0 y_0 z_0 + diffEqns = [diff(x, t) == -x + 1, diff(y, t) == -y, diff(z, t) == -z]; + initCond = [x(0) == x_0, y(0) == y_0, z(0) == z_0]; + soln = dsolve (diffEqns, initCond); + soln = [soln.x, soln.y, soln.z]; + exact_soln = [(x_0 - 1)*exp(-t) + 1 y_0*exp(-t) z_0*exp(-t)]; + assert (isequal (soln, exact_soln)) + end +21 tests, 21 passed, 0 known failure, 0 skipped +[inst/@sym/sech.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sech.m +***** error sech (sym(1), 2) +***** assert (isequaln (sech (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); ***** test - syms x - vpi = vpa(sym(pi), 64); - e = tan(x/4) == 1; - q = vpasolve(e, x, 3.0); - w = q - vpi ; - assert (double(w) < 1e-30) + f1 = sech(x); + f2 = sech(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - syms x - vpi = vpa(sym(pi), 64); - e = tan(x/4) == 1; - q = vpasolve(e, x); - w = q - vpi; - assert (double(w) < 1e-30) - q = vpasolve(e); - w = q - vpi; - assert (double(w) < 1e-30) + D = [d d; d d]; + A = [x x; x x]; + f1 = sech(A); + f2 = sech(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test - % very accurate pi - syms x - e = tan(x/4) == 1; - m = digits(256); - q = vpasolve(e, x, 3); - assert (double(abs(sin(q))) < 1e-256) - digits(m); + % round trip + y = sym('y'); + A = sech (d); + f = sech (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/lambertw.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/lambertw.m ***** test - % very accurate sqrt 2 + % W(x)*exp(W(x)) == x syms x - e = x*x == 2; - m = digits(256); - q = vpasolve(e, x, 1.5); - assert (double(abs(q*q - 2)) < 1e-256) - digits(m); + T = lambertw(x)*exp(lambertw(x)); + T = double (subs (T, x, 10)); + assert (isequal (T, 10)); ***** test - % very accurate sqrt pi - % (used to fail https://github.com/sympy/sympy/issues/8564) + % k, x not x, k to match SMT syms x - e = x*x == sym(pi); - m = digits(256); - q = vpasolve(e, x, 3); - assert (double(abs(sin(q*q))) < 1e-256) - digits(m); -***** test + T = lambertw(2, x)*exp(lambertw(2, x)); + T = double (subs (T, x, 10)); + assert (abs(T - 10) < 1e-15) +***** assert (isequal (lambertw(sym(0)), sym(0))) +***** assert ( isequal (lambertw (-1/exp(sym(1))), -sym(1))) +***** assert ( isequal (lambertw (0, -1/exp(sym(1))), -sym(1))) +***** assert ( isequal (lambertw (-1, -1/exp(sym(1))), -sym(1))) +***** xtest + % W(x)*exp(W(x)) == x; FIXME: a failure in SymPy? syms x - r = vpasolve(x^2 + 2 == 0, x, 1i); - assert (double (imag(r)^2 - 2), 0, 1e-32) - assert (double (real(r)^2), 0, 1e-32) - r = vpasolve(x^2 + 2 == 0, x, -3i + 5); - assert (double (imag(r)^2 - 2), 0, 1e-32) - assert (double (real(r)^2), 0, 1e-32) + T = simplify(lambertw(x)*exp(lambertw(x))); + assert (isequal (T, x)) +!!!!! known failure +assert (isequal (T, x)) failed +***** assert (abs (lambertw(pi) - double(lambertw(sym(pi)))) < 5*eps) +***** assert (abs (lambertw(-1, 5) - double(lambertw(-1, sym(5)))) < 5*eps) +***** assert (abs (lambertw(2, 2) - double(lambertw(2, sym(2)))) < 5*eps) ***** test - % system - syms x y - f = 3*x^2 - 2*y^2 - 1; - g = x^2 - 2*x + y^2 + 2*y - 8; - r = vpasolve([f; g], [x; y], sym([-1; 1])); - assert (isa (r, 'sym')) - assert (numel (r) == 2) + % round trip + syms x k + A = lambertw (5); + f = lambertw (x); + h = function_handle (f); + B = h (5); + assert (A, B) + + A = lambertw (3, 5); + f = lambertw (k, x); + h = function_handle (f); + B = h (3, 5); + assert (A, B) +11 tests, 10 passed, 1 known failure, 0 skipped +[inst/@sym/heaviside.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/heaviside.m +***** error heaviside (sym(1), 2, 3) +***** assert (isequal (heaviside (sym(1)), sym(1))) +***** assert (isequal (heaviside (-sym(1)), sym(0))) +***** assert (double (heaviside (1)), heaviside (1)) ***** test - % system, double guess - syms x y - f = 3*x^2 - 2*y^2 - 1; - g = x^2 - 2*x + y^2 + 2*y - 8; - r = vpasolve([f; g], [x; y], [-1.1 1.2]); + D = [1 -1; -10 20]; + A = sym(D); + assert (double (heaviside (A)), heaviside (D)) ***** test - % system, double guess - syms x y - f = 3*x^2 - 2*y^2 - 1; - g = x^2 - 2*x + y^2 + 2*y - 8; - r1 = vpasolve([f; g], [x; y], [-1.1]); - r2 = vpasolve([f; g], [x; y], [-1.1 -1.1]); - assert (isequal (r1, r2)) + H0 = sym([1 -2 0; 3 0 pi]); + A = heaviside (sym(0), H0); + assert (isequal (A, H0)) ***** test - % system, more eqns than unknowns - syms x y - eqns = [x^3 - x - y == 0; y*exp(x) == 16; log(y) + x == 4*log(sym(2))]; - r = vpasolve (eqns, [x; y], [1; 1]); - A = subs (lhs (eqns), [x; y], r); - err = A - [0; 16; 4*log(sym(2))]; - assert (double (err), zeros (size (err)), 1e-31) -10 tests, 10 passed, 0 known failure, 0 skipped -[inst/vpa.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/vpa.m + A = heaviside ([-1 0 1], sym(1)/2); + assert (isequal (A, [0 sym(1)/2 1])) ***** test - a = vpa(0, 4); - b = double(a); - assert(b == 0) + A = heaviside ([-1 0 1], sym(1)/2); + assert (isequal (A, [0 sym(1)/2 1])) +***** assert (isequaln (heaviside (sym(nan)), sym(nan))) ***** test - a = vpa(pi, 4); - b = sin(a); - assert(abs(double(b)) < 1e-4) + assert (isequaln (heaviside (sym(nan), sym(nan)), sym(nan))) + assert (isequaln (heaviside (0, sym(nan)), sym(nan))) + assert (isequaln (heaviside (2, sym(nan)), sym(1))) + assert (isequaln (heaviside (-2, sym(nan)), sym(0))) ***** test - % vpa from double is ok, doesn't warn (c.f., sym(2.3)) - a = vpa(2.3); - assert(true) + % round trip + syms x + A = heaviside (1); + f = heaviside (x); + h = function_handle (f); + B = h (1); + assert (A, B, -eps) ***** test - % vpa from double not more than 16 digits - a = vpa(sqrt(pi), 32); - b = sin(a^2); - assert(abs(double(b)) > 1e-20) - assert(abs(double(b)) < 1e-15) + % round trip + syms x h0 + f = heaviside (x, h0); + h = function_handle (f, 'vars', {x h0}); + A = heaviside (1, 1/2); + B = h (1, 1/2); + assert (A, B, -eps) + A = heaviside (0, 1/2); + B = h (0, 1/2); + assert (A, B, -eps) +12 tests, 12 passed, 0 known failure, 0 skipped +[inst/@sym/factor.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/factor.m ***** test - a = vpa(sym(pi), 32); - b = sin(a); - assert(abs(double(b)) < 1e-30) + % n = 152862; + % [p,m] = factor(n); % only works on Octave, no Matlab as of 2014a + n = 330; % so we use an output without repeated factors + p = factor(n); m = ones(size(p)); + [ps,ms] = factor(sym(n)); + assert (isequal (p, ps)) + assert (isequal (m, ms)) ***** test - a = vpa(sym(pi), 256); - b = sin(a); - assert(abs(double(b)) < 1e-256) + n = sym(2)^4*13; + [p,m] = factor(n); + assert (isequal (p, [2 13])) + assert (isequal (m, [4 1])) +***** test syms x + assert( logical (factor(x^2 + 6*x + 5) == (x+5)*(x+1))) ***** test - % pi str - a = vpa('pi', 32); - b = sin(a); - assert(abs(double(b)) < 1e-32) + syms x + f = [ x^4/2 + 5*x^3/12 - x^2/3 x^2 - 1 10]; + g = [ x^2*(2*x - 1)*(3*x + 4)/12 (x+1)*(x-1) 10]; + assert (isequal (factor(f), g)) ***** test - % pi str - a = vpa('pi', 32); - b = vpa(sym('pi'), 32); - assert (double (a - b) == 0) + % "fragile form" works + A = factor(sym(124)); + B = strtrim(disp(A, 'flat')); + assert (strcmp (B, '2**2*31**1')) +***** error [p, m] = factor(sym('x')); +***** error [p, m] = factor(sym(42), sym('x')); ***** test - spi = sym(pi); - a = vpa(spi, 10); - b = double(a); - assert(~isAlways(spi == a)) + % if polynomial happens to be a constant, don't attempt integer + % factorization if a variable is specified + f = sym(42); + q = factor(f, sym('x')); + assert (isequal (f, q)); +8 tests, 8 passed, 0 known failure, 0 skipped +[inst/@sym/asind.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/asind.m +***** error asind (sym(1), 2) +***** assert (isequaln (asind (sym(nan)), sym(nan))) ***** test - % matrix of sym - a = [sym(pi) 0; sym(1)/2 1]; - b = [pi 0; 0.5 1]; - c = vpa(a, 6); - assert(max(max(abs(double(c)-b))) < 1e-6) + f1 = asind (sym(1)/2); + f2 = asind (1/2); + assert (double (f1), f2, -eps) ***** test - % matrix of double - b = [pi 0; 0.5 1]; - c = vpa(b, 6); - assert(max(max(abs(double(c)-b))) < 1e-6) + D = [1 2; 3 4]/4; + A = sym([1 2; 3 4])/4; + f1 = asind (A); + f2 = asind (D); + assert (double (f1), f2, -eps) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/gradient.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/gradient.m +***** shared x,y,z + syms x y z ***** test - % integer type - a = vpa(int32(6), 64); - b = vpa(6, 64); - assert (isequal (a, b)) + % 1D + f = x^2; + assert (isequal (gradient(f), diff(f,x))) + assert (isequal (gradient(f,{x}), diff(f,x))) + assert (isequal (gradient(f,[x]), diff(f,x))) + assert (isequal (gradient(f,x), diff(f,x))) ***** test - % matrix of int - b = int32([pi 0; 6.25 1]); - c = vpa(b, 6); - assert (isequal (double(c), [3 0; 6 1])) + % const + f = sym(1); + g = sym(0); + assert (isequal (gradient(f), g)) + assert (isequal (gradient(f,x), g)) ***** test - % can pass pi directly to vpa - a = vpa(sym(pi), 128); - b = vpa(pi, 128); - assert (isequal (a, b)) + % double const + f = 1; + g = sym(0); + assert (isequal (gradient(f,x), g)) ***** test - % if sym does sth special for e so should vpa - a = vpa(sym(exp(1)), 64); - b = vpa(exp(1), 64); - assert (isequal (a, b)) + % 1D fcn in 2d/3d + f = sin(y); + assert (isequal (gradient(f), diff(f,y))) + assert (isequal (gradient(f, {x,y}), [sym(0); diff(f,y)])) + assert (isequal (gradient(f, [x y]), [sym(0); diff(f,y)])) + assert (isequal (size (gradient(f, {x,y})), [2 1])) + assert (isequal (gradient(f, {x,y,z}), [0; diff(f,y); 0])) + assert (isequal (gradient(f, [x y z]), [0; diff(f,y); 0])) + assert (isequal (size (gradient(f, {x,y,z})), [3 1])) ***** test - % can pass pi directly to vpa, even in array - a = vpa(sym([2 pi]), 128); - b = vpa([2 pi], 128); - assert (isequal (a, b)) + % grad is column vector + f = sin(y); + assert (isequal (size (gradient(f, {x,y})), [2 1])) + assert (isequal (size (gradient(f, {x,y,z})), [3 1])) + assert (isequal (size (gradient(f, [x y])), [2 1])) + assert (isequal (size (gradient(f, [x;y])), [2 1])) ***** test - % can pass i directly to vpa - a = vpa(sym(i)); - b = vpa(i); + % 2d fcn in 2d/3d + f = sin(exp(x)*y); + g2 = [diff(f,x); diff(f,y)]; + g3 = [diff(f,x); diff(f,y); diff(f,z)]; + assert (isequal (gradient(f), g2)) + assert (isequal (gradient(f, {x,y}), g2)) + assert (isequal (gradient(f, {x,y,z}), g3)) ***** test - % 'i' and 'I' just make vars - a = vpa(sym(1i)); - b = vpa('i'); - c = vpa('I'); - assert (~isequal (a, b)) - assert (~isequal (a, c)) + % 2d fcn in 2d/3d + f = sin(exp(x)*y+sinh(z)); + g2 = [diff(f,x); diff(f,y)]; + g3 = [diff(f,x); diff(f,y); diff(f,z)]; + assert (isequal (gradient(f), g3)) + assert (isequal (gradient(f, {x,y}), g2)) + assert (isequal (gradient(f, {x,y,z}), g3)) +***** error gradient(sym('x'), 42, 42) +***** error gradient([sym('x') sym('x')]) +9 tests, 9 passed, 0 known failure, 0 skipped +[inst/@sym/any.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/any.m ***** test - % '1i' and '1j' strings - a = vpa(sym(1i)); - b = vpa('1i'); - c = vpa('1j'); - assert (isequal (a, b)) - assert (isequal (a, c)) + % matrix + a = [0 0; 1 0]; + s = sym(a); + assert (isequal (any (s), any (a))) + assert (isequal (any (s,1), any (a,1))) + assert (isequal (any (s,2), any (a,2))) ***** test - % Issue #868, precision loss on '0.33j' - a = vpa('0.33j', 40); - b = vpa('0.33i', 40); - assert (double (abs (imag (a)*100/33) - 1) < 1e-39) - assert (isequal (a, b)) + % vector + a = [0 1 0]; + s = sym(a); + assert (isequal (any (s), any (a))) + assert (isequal (any (s,1), any (a,1))) + assert (isequal (any (s,2), any (a,2))) ***** test - % inf/-inf do not become symbol('inf') - S = {'oo', '-oo', 'inf', 'Inf', '-inf', '+inf'}; - for j = 1:length(S) - a = vpa(S{j}); - b = vpa(sym(S{j})); - assert (isequal (a, b)) + % should fail on symbols + syms x + s = [0 1 x]; + try + any (s) + waserr = false; + catch + waserr = true; end + assert (waserr) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/disp.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/disp.m ***** test - a = vpa('2.3', 20); - s = strtrim(disp(a, 'flat')); - assert (strcmp (s, '2.3000000000000000000')) -***** test - % these should *not* be the same - a = vpa(2.3, 40); - b = vpa('2.3', 40); - sa = sympy (a); - sb = sympy (b); - assert (~isequal (a, b)) - assert (abs(double(a - b)) > 1e-20) - assert (abs(double(a - b)) < 1e-15) - assert (~strcmp(sa, sb)) -***** test - % these should *not* be the same - x = vpa('1/3', 32); - y = vpa(sym(1)/3, 32); - z = vpa(1/3, 32); - assert (isequal (x, y)) - assert (~isequal (x, z)) -***** test - % big integers - a = int64(12345678); - a = a*a; - b = vpa(a); - c = vpa('152415765279684'); - assert (isequal (b, c)) + syms x + s = disp(sin(x)); + assert(strcmp(s, sprintf(' sin(x)\n'))) ***** test - % big integers (workaround poor num2str, works in 4.0?) - a = int64(1234567891); a = a*a; - b = vpa(a); - c = vpa('1524157877488187881'); - assert (isequal (b, c)) + syms x + s = disp(sin(x/2), 'flat'); + assert(strcmp(s, sprintf(' sin(x/2)\n'))) ***** test - % isequal and other comparisons - a = vpa ("2/3", 32); - b = vpa ("2/3", 64); - assert (~ logical (a == b)) - assert (~ isequal (a, b)) - a = vpa ("1/3", 32); - b = vpa ("1/3", 64); - assert (~ logical (a == b)) - assert (~ isequal (a, b)) - a = vpa ("0.1", 32); - b = vpa ("0.1", 64); - assert (~ logical (a == b)) - assert (~ isequal (a, b)) + % Examples of 2x0 and 0x2 empty matrices: + a = sym([1 2; 3 4]); + b2x0 = a([true true], [false false]); + b0x2 = a([false false], [true true]); + assert (isequal (size (b2x0), [2 0])) + assert (isequal (size (b0x2), [0 2])) + s = disp(b2x0); + assert(strcmp(s, sprintf(' []\n'))) + s = disp(b0x2); + assert(strcmp(s, sprintf(' []\n'))) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/length.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/length.m ***** test - % isequal with array: Issue #1285 - a = vpa ("2/3", 32); - b = vpa ("2/3", 64); - assert (~ isequal ([a 2*a], [b 2*b])) -***** xtest - % non-equality of vpa that "might be" be integers: Issue #1285 - a = vpa ("123", 32); - b = vpa ("123", 64); - assert (~ logical (a == b)) -!!!!! known failure -assert (!logical (a == b)) failed -***** xtest - % non-equality of vpa that "might be" be integers: Issue #1285 - if (pycall_sympy__ ('return Version(spver) >= Version("1.12.1")')) - a = vpa ("123", 32); - b = vpa ("123", 64); - assert (~ isequal (a, b)) - end -***** warning vpa ('sqrt(2.0)'); -***** warning - a = vpa('2**0.5'); - b = vpa(sqrt(sym(2))); - assert (isequal (a, b)) + a = sym([1 2 3]); + assert(length(a) == 3); ***** test - a = vpa('2.3e1'); - b = vpa(' 2.3e+1 '); - assert (isequal (a, b)) - a = vpa('21e-1'); - b = vpa('2.1'); - assert (isequal (a, b)) + % 2D array + a = sym([1 2 3; 4 5 6]); + assert(length(a) == 3); ***** test - % Issue #859, operations on immutable matrices - x = vpa (sym ([1 2])); - % If vpa no longer makes an ImmutableDenseMatrix, - % may need to adjust or remove this test. - assert (~ isempty (strfind (sympy (x), 'Immutable'))) - y = sin(x); - y2 = [sin(vpa(sym(1))) sin(vpa(sym(2)))]; - assert (isequal (y, y2)) -34 tests, 33 passed, 1 known failure, 0 skipped -[inst/eulergamma.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/eulergamma.m -***** error catalan (sym(1)) -***** assert (double (eulergamma ()) > 0.577215664901) -***** assert (double (eulergamma ()) < 0.577215664902) + % empty + a = sym([]); + assert(length(a) == 0); 3 tests, 3 passed, 0 known failure, 0 skipped -[inst/digits.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/digits.m +[inst/@sym/min.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/min.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/@double/pochhammer.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/pochhammer.m -***** error pochhammer (1) -***** error pochhammer (1, 2, 3) -***** error pochhammer ([1 2], [1 2 3]) -***** error pochhammer ([1 2], [1; 2]) + % scalars with dim + a = min(sym(pi), [], 1); + b = sym(pi); + assert (isequal (a, b)); + a = min(sym(pi), [], 2); + assert (isequal (a, b)); + a = max(sym(pi), [], 1); + assert (isequal (a, b)); + a = max(sym(pi), [], 2); + assert (isequal (a, b)); +***** shared A, D + D = [0 1 2 3]; + A = sym(D); ***** test - y = sym(11)/10; - t = sym(3); - x = 1.1; - s = 3; - A = pochhammer (x, s); - B = double (pochhammer (y, t)); - assert (A, B, -2*eps); + % row vectors + assert (isequal (min(A), sym(min(D)))) + assert (isequal (min(A), sym(0))) + assert (isequal (max(A), sym(max(D)))) + assert (isequal (max(A), sym(3))) ***** test - % maple - A = 256.798558090310131720; - B = pochhammer (18.1, 1.9); - assert (A, B, -20*eps) + % row vectors with dim + assert (isequal (min(A, [], 1), sym(min(D, [], 1)))) + assert (isequal (min(A, [], 2), sym(min(D, [], 2)))) + assert (isequal (max(A, [], 1), sym(max(D, [], 1)))) + assert (isequal (max(A, [], 2), sym(max(D, [], 2)))) ***** test - % maple, complex inputs> - A = 2.67921619474318221972 + 1.96716724764630702653*1i; - B = pochhammer (12.1+3.1*i, 0.5+0.2i); - assert (A, B, -4*eps); + % column vectors + A = A.'; + D = D.'; + assert (isequal (min(A), sym(min(D)))) + assert (isequal (min(A), sym(0))) + assert (isequal (max(A), sym(max(D)))) + assert (isequal (max(A), sym(3))) ***** test - % maple, matrix inputs - A = [5.61467232547723663908 20.6144884613920190965]; - B = pochhammer ([0.9 0.8], [3.1 4.2]); - assert (A, B, -3*eps); + % row vectors with dim + assert (isequal (min(A, [], 1), sym(min(D, [], 1)))) + assert (isequal (min(A, [], 2), sym(min(D, [], 2)))) + assert (isequal (max(A, [], 1), sym(max(D, [], 1)))) + assert (isequal (max(A, [], 2), sym(max(D, [], 2)))) +***** shared ***** test - % x matrix, s scalar - y = [1 2 sym(pi); exp(sym(1)) 5 6]; - t = sym(2); - x = double (y); - s = 2; - A = pochhammer (s, x); - B = double (pochhammer (t, y)); - assert (A, B, -3*eps); + % empty + a = min(sym([])); + assert(isempty(a)) + a = max(sym([])); + assert(isempty(a)) ***** test - % s matrix, x scalar - t = [1 2 sym(pi); exp(sym(1)) 5 6]; - y = sym(2); - s = double (t); - x = 2; - A = pochhammer (s, x); - B = double (pochhammer (t, y)); - assert (A, B, -5*eps); -10 tests, 10 passed, 0 known failure, 0 skipped -[inst/@double/euler.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/euler.m -***** error euler (1, 2, 3) -***** error euler ([1 2], [1 2 3]) -***** error euler ([1 2], [1; 2]) -***** assert (isequal (euler (0), 1)) -***** assert (isequal (euler (1), 0)) -***** assert (isequal (euler (10), -50521)) + % matrix + A = [1 4 6; 2 2 5]; + A = sym(A); + assert (isequal (min(A), sym([1 2 5]))) + assert (isequal (min(A, [], 1), sym([1 2 5]))) + assert (isequal (min(A, [], 2), sym([1; 2]))) + assert (isequal (max(A), sym([2 4 6]))) + assert (isequal (max(A, [], 1), sym([2 4 6]))) + assert (isequal (max(A, [], 2), sym([6; 5]))) ***** test - n = sym(88); - m = 88; - A = euler (m); - B = double (euler (n)); - assert (A, B, -eps); + % index output is double not sym + [m, I] = min(sym(2), [], 1); + assert (strcmp(class(I), 'double')) + [m, I] = max(sym(2), [], 1); + assert (strcmp(class(I), 'double')) ***** test - m = [0 1; 2 4]; - n = sym(m); - A = euler (m); - B = double (euler (n)); - assert (isequal (A, B)); + % empty rows/columns, I is double + A = sym(zeros(0, 4)); + [m, I] = min(A, [], 1); + assert (strcmp(class(I), 'double')) + [m, I] = max(A, [], 1); + assert (strcmp(class(I), 'double')) + A = sym(zeros(3, 0)); + [m, I] = min(A, [], 2); + assert (strcmp(class(I), 'double')) + [m, I] = max(A, [], 2); + assert (strcmp(class(I), 'double')) ***** test - y = sym(19)/10; - n = sym(2); - x = 1.9; - m = 2; - A = euler (m, x); - B = double (euler (n, y)); - assert (A, B, -eps); + % index output + A = [0 1 9; 10 7 4]; + B = sym(A); + [m1, I1] = min(A); + [m2, I2] = min(B); + assert (isequal (I1, I2)) + assert (isequal (m1, double(m2))) + [m1, I1] = max(A); + [m2, I2] = max(B); + assert (isequal (I1, I2)) + assert (isequal (m1, double(m2))) ***** test - % correct behaviour at floating point infinity - assert (isequal (euler (4, inf), inf)) - assert (isequal (euler (4, -inf), inf)) - assert (isequal (euler (3, inf), inf)) - assert (isequal (euler (3, -inf), -inf)) + % index output, with dim + A = [0 1 9; 10 7 4]; + B = sym(A); + [m1, I1] = min(A, [], 1); + [m2, I2] = min(B, [], 1); + assert (isequal (I1, I2)) + assert (isequal (m1, double(m2))) + [m1, I1] = min(A, [], 2); + [m2, I2] = min(B, [], 2); + assert (isequal (I1, I2)) + assert (isequal (m1, double(m2))) + [m1, I1] = max(A, [], 1); + [m2, I2] = max(B, [], 1); + assert (isequal (I1, I2)) + assert (isequal (m1, double(m2))) + [m1, I1] = max(A, [], 2); + [m2, I2] = max(B, [], 2); + assert (isequal (I1, I2)) + assert (isequal (m1, double(m2))) ***** test - assert (isnan (euler(3, nan))) - assert (isnumeric (euler(3, nan))) + % empty columns + A = sym(zeros(0, 4)); + [m, I] = min(A, [], 1); + assert (isequal (size(m), [0 4])) + assert (isequal (size(I), [0 4])) + [m, I] = max(A, [], 1); + assert (isequal (size(m), [0 4])) + assert (isequal (size(I), [0 4])) ***** test - % maple, complex input - A = 113.33970046079423204 - 46.991080726974811540i; - B = euler(7, 2.12345 + 1.23i); - assert (A, B, -eps); + % empty rows + A = sym(zeros(3, 0)); + [m, I] = min(A, [], 2); + assert (isequal (size(m), [3 0])) + assert (isequal (size(I), [3 0])) + [m, I] = max(A, [], 2); + assert (isequal (size(m), [3 0])) + assert (isequal (size(I), [3 0])) ***** test - % maple, complex input, large m, small x - A = 0.18034673393294025238e276 + 0.27756266681280689172e276*i; - B = euler (200, 0.123+0.234i); - assert (A, B, -eps); + % another empty case + % we differ slightly from double which gives 1x0/0x1 + A = sym(zeros(3, 0)); + [m, I] = min(A, [], 1); + assert (isempty (m)) + assert (isempty (I)) + A = sym(zeros(0, 3)); + [m, I] = min(A, [], 2); + assert (isempty (m)) + assert (isempty (I)) ***** test - % x matrix, m scalar - y = [1 2 sym(pi); exp(sym(1)) 5 6]; - n = sym(2); - x = double (y); - m = 2; - A = euler (m, x); - B = double (euler (n, y)); - assert (A, B, -eps); + % empty without index output + A = sym(zeros(3, 0)); + assert (isempty (min (A, [], 1))) + assert (isempty (max (A, [], 1))) + assert (isempty (min (A, [], 2))) + assert (isempty (max (A, [], 2))) + A = sym(zeros(0, 3)); + assert (isempty (min (A, [], 1))) + assert (isempty (max (A, [], 1))) + assert (isempty (min (A, [], 2))) + assert (isempty (max (A, [], 2))) ***** test - % m matrix, x scalar - m = [1 2 3; 4 5 6]; - n = sym(m); - y = sym(21)/10; - x = 2.1; - A = euler (m, x); - B = double (euler (n, y)); - assert (A, B, -3*eps); -15 tests, 15 passed, 0 known failure, 0 skipped -[inst/@double/adjoint.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/adjoint.m + % binary op form, one a scalar + A = sym([3 1 9]); + m = min(A, sym(2)); + M = max(A, sym(2)); + assert (isequal (m, sym([2 1 2]))) + assert (isequal (M, sym([3 2 9]))) + m = min(sym(2), A); + M = max(sym(2), A); + assert (isequal (m, sym([2 1 2]))) + assert (isequal (M, sym([3 2 9]))) ***** test - M = [1 2; 3 4]; - A = [4 -2; -3 1]; - assert (isequal (adjoint (M), A)); + % binary op form, both scalar + m = min(sym(1), sym(2)); + M = max(sym(2), sym(2)); + assert (isequal (m, sym(1))) + assert (isequal (M, sym(2))) ***** test - assert (isequal (adjoint (42), 1)); -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@double/fresnels.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/fresnels.m -***** error fresnels (1, 2) + syms x y + assert (isequal (children (min (x, y)), [x y])) ***** test - x = 1.1; - y = sym(11)/10; - A = fresnels (x); - B = double (fresnels (y)); - assert (A, B, -4*eps); + syms x y z + A = [x 1; y z]; + assert (isequal (min (A, [], 1), [min(x, y) min(1, z)])) + assert (isequal (max (A, [], 1), [max(x, y) max(1, z)])) + assert (isequal (min (A, [], 2), [min(x, 1); min(y, z)])) + assert (isequal (max (A, [], 2), [max(x, 1); max(y, z)])) ***** test - y = [2 3 sym(pi); exp(sym(1)) 5 6]; - x = double (y); - A = fresnels (x); - B = double (fresnels (y)); - assert (A, B, -4*eps); + syms x y positive + a = min([x 2 y -6]); + assert (isequal (a, -6)) + a = max([x y -6]); + assert (isequal (a, max(x, y))) ***** test - % maple: - % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; - % > for a in A do evalf(FresnelS(a)) end do; - x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; - A = [ 36.725464883991438430 + 15.587751104404587334*1i - 0.12213736710980573217e13 - 0.47688568479924574726e12*1i - 0.49681690114783755327 - -0.46816997858488224040*1i - -0.52344169596561937423e-12 + 0.15707439669173367248e-13*1i - 0.75738824160998910399e24 + 0.15391592966931193100e26*1i ]; - B = fresnels (x); - assert (A, B, -eps) -***** assert (fresnels (inf), 0.5) -***** assert (fresnels (-inf), -0.5) -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@double/bernoulli.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/bernoulli.m -***** error bernoulli (1, 2, 3) -***** error bernoulli ([1 2], [1 2 3]) -***** error bernoulli ([1 2], [1; 2]) -***** assert (bernoulli (0), 1) -***** assert (bernoulli (3), 0) + syms x negative + a = min([x 6 10]); + assert (isequal (a, x)) + a = max([x -2 6]); + assert (isequal (a, 6)) +21 tests, 21 passed, 0 known failure, 0 skipped +[inst/@sym/diag.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/diag.m ***** test - % two different definitions in literature - assert (abs (bernoulli (1)), 0.5, -eps) -***** xtest - % we want to use B_1 = 1/2, possible with a version-specific filter - assert (bernoulli (1), 0.5, -eps) -!!!!! known failure -ASSERT errors for: assert (bernoulli (1),0.5,-eps) - - Location | Observed | Expected | Reason - () -0.5 0.5 Rel err 2 exceeds tol 2.2204e-16 by 2 + % scalar + syms x + assert (isequal (diag(x), x)) ***** test - n = sym(88); - m = 88; - A = bernoulli (m); - B = double (bernoulli (n)); - assert (A, B, -eps); + % row,col vec input + syms x + r = [1 x 2]; + c = [sym(1); x]; + assert (isequal (diag(diag(c)), c)) + assert (isequal (diag(c), [sym(1) 0; 0 x])) + assert (isequal (diag(diag(r)), r.')) + assert (isequal (diag(r), [sym(1) 0 0; 0 x 0; sym(0) 0 2])) ***** test - m = [0 2; 3 4]; - n = sym(m); - A = bernoulli (m); - B = double (bernoulli (n)); - assert (isequal (A, B)); + % create matrix, kth diag + syms x + r = [1 x]; + z = sym(0); + assert (isequal (diag (x, 0), x)) + assert (isequal (diag (x, 1), [z x; z z])) + assert (isequal (diag (x, -1), [z z; x z])) + assert (isequal (diag (x, 2), [z z x; z z z; z z z])) + assert (isequal (diag (r, 1), [z 1 z; z z x; z z z])) ***** test - y = sym(19)/10; - n = sym(2); - x = 1.9; - m = 2; - A = bernoulli (m, x); - B = double (bernoulli (n, y)); - assert (A, B, -eps); + % extract kth diag + A = sym([1 2 3; 4 5 6]); + assert (isequal (diag(A), sym([1; 5]))) + assert (isequal (diag(A, 0), sym([1; 5]))) + assert (isequal (diag(A, 1), sym([2; 6]))) + assert (isequal (diag(A, 2), sym(3))) + assert (isequal (diag(A, -1), sym(4))) + assert (isempty (diag(A, -2))) + assert (isempty (diag(A, 3))) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/log2.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/log2.m +***** assert (isequal (log2 (sym (1024)), sym (10))) +***** assert (isequal (log2 (sym ([2 16; 32 1])), sym ([1 4; 5 0]))) ***** test - assert (isequal (bernoulli (4, inf), inf)) - assert (isequal (bernoulli (4, -inf), inf)) -***** xtest - % still broken? - assert (isequal (bernoulli (3, inf), inf)) - assert (isequal (bernoulli (3, -inf), -inf)) + % round-trip + syms x + f = log2 (x); + h = function_handle (f); + A = h (1.1); + B = log2 (1.1); + assert (A, B, -5*eps) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/ellipticCK.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipticCK.m +***** error ellipticCK (sym (1), 2) +***** assert (double (ellipticCK (sym (1)/2)), 1.8541, 10e-5) +***** assert (double (ellipticCK (sym (101)/10)), 0.812691836806976, -3*eps) +***** assert (isequal (ellipticCK (sym (1)), sym(pi)/2)) +4 tests, 4 passed, 0 known failure, 0 skipped +[inst/@sym/besselj.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/besselj.m ***** test - assert (isnan (bernoulli(3, nan))) - assert (isnumeric (bernoulli(3, nan))) + X = [1 2 3; 4 5 6]; + ns = [sym(0) 1 -2; sym(1)/2 -sym(3)/2 pi]; + n = double(ns); + A = double(besselj(ns, X)); + B = besselj(n, X); + assert (all (all (abs (A - B) < 50*eps*abs(A)))) ***** test - % maple, complex input - A = 34.21957245745810513 - 130.0046256649829101i; - B = bernoulli(7, 2.123 + 1.234i); - assert (A, B, -5*eps); + % roundtrip + syms x + A = besselj(2, 10); + q = besselj(2, x); + h = function_handle(q); + B = h(10); + assert (abs (A - B) <= eps*abs(A)) +***** error besselj(sym('x')) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/dirac.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/dirac.m +***** error dirac (sym(1), 2) +***** assert (isequaln (dirac (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); ***** test - % x matrix, m scalar - y = [1 2 sym(pi); exp(sym(1)) 5 6]; - n = sym(2); - x = double (y); - m = 2; - A = bernoulli (m, x); - B = double (bernoulli (n, y)); - assert (A, B, -eps); + f1 = dirac(x); + f2 = dirac(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - % m matrix, x scalar - m = [1 2 3; 4 5 6]; - n = sym(m); - y = sym(21)/10; - x = 2.1; - A = bernoulli (m, x); - B = double (bernoulli (n, y)); - assert (A, B, -3*eps); -16 tests, 15 passed, 1 known failure, 0 skipped -[inst/@double/sinhint.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/sinhint.m -***** error sinhint (1, 2) + D = [d d; d d]; + A = [x x; x x]; + f1 = dirac(A); + f2 = dirac(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test - x = 1.1; - y = sym(11)/10; - A = sinhint (x); - B = double (sinhint (y)); - assert (A, B, -4*eps); + % round trip + y = sym('y'); + A = dirac (d); + f = dirac (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/ge.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ge.m ***** test - y = [2 3 sym(pi); exp(sym(1)) 5 6]; - x = double (y); - A = sinhint (x); - B = double (sinhint (y)); - assert (A, B, -4*eps); + % simple + x = sym(1); y = sym(1); e = x >= y; + assert (logical (e)) + x = sym(1); y = sym(2); e = x >= y; + assert (~logical(e)) ***** test - % maple: - % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; - % > for a in A do evalf(Shi(a)) end do; - x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; - A = [ 0.45769171128668800567 + 1.8332099215048436239*1i - 0.60888490416819746440 + 1.2482232175376056201*1i - 0.13577763724269399110e42 - 1.6583475942188740493*1i - -0.00010000000005553888891 + 0.10000000016666111119e-5*1i - -0.74701205140887967022e7 - 0.10381447401236722090e8*1i ]; - B = sinhint (x); - assert (A, B, -eps) -***** assert (sinhint (inf), inf) -***** assert (sinhint (-inf), -inf) -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@double/logint.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/logint.m -***** error logint (1, 2) + % array -- array + syms x + a = sym([1 3 3 2*x]); + b = sym([2 x 3 10]); + e = a >= b; + assert (isa (e, 'sym')) + assert (~logical (e(1))) + assert (isa (e(2), 'sym')) + assert (isequal (e(2), 3 >= x)) + assert (logical (e(3))) + assert (isa (e(4), 'sym')) + assert (isequal (e(4), 2*x >= 10)) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/csc.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/csc.m +***** error csc (sym(1), 2) +***** assert (isequaln (csc (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); ***** test - x = 1.1; - y = sym(11)/10; - A = logint (x); - B = double (logint (y)); - assert (A, B, -4*eps); + f1 = csc(x); + f2 = csc(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - y = [2 3 sym(pi); exp(sym(1)) 5 6]; - x = double (y); - A = logint (x); - B = double (logint (y)); - assert (A, B, -4*eps); + D = [d d; d d]; + A = [x x; x x]; + f1 = csc(A); + f2 = csc(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test - % maple: - % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; - % > for a in A do evalf(Li(a)) end do; - x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; - A = [ 1.3876787420229375511 + 2.5087546988592328752*1i - 1.6987684473874802274 + 4.5936366057115204667*1i - 30.126141584079629926 - 3.4936715673748995398 + 5.5260023797127391973*1i - 0.90264689772681592152e-5 + 3.1415953634267361942*1i - -2.3996350854560916779 - 7.6971739096353664559*1i ]; - B = logint (x); + % round trip + y = sym('y'); + A = csc (d); + f = csc (y); + h = function_handle (f); + B = h (d); assert (A, B, -eps) -***** assert (logint (inf), inf) -***** assert (isnan (logint (-inf))) -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@double/sinint.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/sinint.m -***** error sinint (1, 2) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/invhilb.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/invhilb.m ***** test - x = 1.1; - y = sym(11)/10; - A = sinint (x); - B = double (sinint (y)); - assert (A, B, -4*eps); + A = invhilb(sym(3)); + B = sym([9 -36 30;-36 192 -180;30 -180 180]); + assert( isequal( A, B)) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@sym/angle.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/angle.m ***** test - y = [2 3 sym(pi); exp(sym(1)) 5 6]; - x = double (y); - A = sinint (x); - B = double (sinint (y)); - assert (A, B, -4*eps); -***** assert (sinint (0), 0) -***** assert (sinint (inf), pi/2) -***** assert (sinint (-inf), -pi/2) -***** assert (sinint (1), 0.9460830703671830149414, -2*eps) -***** assert (sinint (-1), -0.9460830703671830149414, -2*eps) -***** assert (sinint (pi), 1.851937051982466170361, -2*eps) -***** assert (sinint (-pi), -1.851937051982466170361, -2*eps) -***** assert (sinint (300), 1.5708810882137495193, -2*eps) -***** assert (sinint (1e4), 1.5708915453859619157, -2*eps) -***** assert (sinint (20i), 1.2807826332028294459e7*1i, -2*eps) + Z = [sqrt(sym(3)) + 3*sym(i), 3 + sqrt(sym(3))*sym(i); 1 + sym(i), sym(i)]; + Q = [sym(pi)/3 sym(pi)/6; sym(pi)/4 sym(pi)/2]; + assert( isequal( angle(Z), Q)); ***** test - % maple: - % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; - % > for a in A do evalf(Si(a)) end do; - x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; - A = [ 1.6782404878293681180 + 2.0396845546022061045*1i - -18.154174221650281533 + 1.6146414539230479060*1i - 1.5622254668890562934 - 1246.1144901994233444*1i - -0.000099999999944461111128 + 0.99999999833338888972e-6*1i - -1.5386156269726011209 - 0.053969388020443786229*1i ]; - B = sinint (x); + % roundtrip + syms x + A = angle (2+2i); + f = angle (x); + h = function_handle (f); + B = h (2+2i); assert (A, B, -eps) -14 tests, 14 passed, 0 known failure, 0 skipped -[inst/@double/harmonic.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/harmonic.m -***** error harmonic (1, 2) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/ellipticF.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ellipticF.m +***** error ellipticF (sym(1)) +***** error ellipticF (sym(1), 2, 3) +***** assert (double (ellipticF (sym (pi)/3, sym (-105)/10)), 0.6184459461, 10e-11) +***** assert (double (ellipticF (sym (pi)/4, sym (-pi))), 0.6485970495, 10e-11) +***** assert (double (ellipticF (sym (1), sym (-1))), 0.8963937895, 10e-11) +***** assert (double (ellipticF (sym (pi)/6, sym (0))), 0.5235987756, 10e-11) ***** test - x = 1.1; - y = sym(11)/10; - A = harmonic (x); - B = double (harmonic (y)); - assert (A, B, -4*eps); + % compare to Maple + us = vpa (ellipticF (sym(11)/10, sym(9)/4), 40); + % > evalf(EllipticF(sin(11/10), sqrt(9/4)), 40); + maple = vpa ('1.206444996991058996424988192917728014427', 40) - ... + vpa ('0.8157358125823472313001683083685348517476j', 40); + assert (abs (double (maple - us)), 0, 1e-39) +7 tests, 7 passed, 0 known failure, 0 skipped +[inst/@sym/fourier.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/fourier.m ***** test - y = [2 3 sym(pi); exp(sym(1)) 5 6]; - x = double (y); - A = harmonic (x); - B = double (harmonic (y)); - assert (A, B, -4*eps); -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@double/coshint.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/coshint.m -***** error coshint (1, 2) + % matlab SMT compatibility for arguments + syms r x u w v + Pi=sym('pi'); + assert(logical( fourier(exp(-x^2)) == sqrt(Pi)/exp(w^2/4) )) + assert(logical( fourier(exp(-w^2)) == sqrt(Pi)/exp(v^2/4) )) + assert(logical( fourier(exp(-r^2),u) == sqrt(Pi)/exp(u^2/4) )) + assert(logical( fourier(exp(-r^2),r,u) == sqrt(Pi)/exp(u^2/4) )) ***** test - x = 1.1; - y = sym(11)/10; - A = coshint (x); - B = double (coshint (y)); - assert (A, B, -4*eps); + % basic tests + syms x w + assert(logical( fourier(exp(-abs(x))) == 2/(w^2 + 1) )) + assert(logical( fourier(x*exp(-abs(x))) == -(w*4*1i)/(w^4 + 2*w^2 + 1) )) ***** test - y = [2 3 sym(pi); exp(sym(1)) 5 6]; - x = double (y); - A = coshint (x); - B = double (coshint (y)); - assert (A, B, -4*eps); + % Dirac delta tests + syms x w + Pi=sym('pi'); + assert(logical( fourier(dirac(x-2)) == exp(-2*1i*w) )) + assert (logical( fourier(sym(2), x, w) == 4*Pi*dirac(w) )) ***** test - % maple: - % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; - % > for a in A do evalf(Chi(a)) end do; - x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; - A = [ 0.58447599687824767874 + 1.8682915044330306402*1i - -0.63131069034703116988 + 1.8986171211850702957*1i - 0.13577763724269399110e42 - -0.045456433004455372635 + 1.5707963267948966192*1i - -8.6330747070747332203 + 3.1315929868531280002*1i - 0.74701205140887966531e7 + 0.10381444259644068585e8*1i ]; - B = coshint (x); - assert (A, B, -eps) -***** assert (coshint (inf), inf) -***** assert (isinf (coshint (-inf))) -***** assert (imag (coshint (-inf)), pi) -7 tests, 7 passed, 0 known failure, 0 skipped -[inst/@double/chebyshevT.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/chebyshevT.m -***** error chebyshevT (1) -***** error chebyshevT (1, 2, 3) -***** error chebyshevT ([1 2], [1 2 3]) -***** error chebyshevT ([1 2], [1; 2]) + % advanced test + syms x w c d + Pi=sym('pi'); + F=Pi*(dirac(w-c)+dirac(w+c))+2*Pi*1i*(dirac(w+3*d)-dirac(w-3*d))+2/(w^2+1); + assert(logical( fourier(cos(c*x)+2*sin(3*d*x)+exp(-abs(x))) == expand(F) )) +***** xtest + % Differential operator to algebraic + % SymPy cannot evaluate? (Issue #170) + syms x w f(x) + assert(logical( fourier(diff(f(x),x),x,w) == -1i*w*fourier(f(x),x,w) )) +!!!!! known failure +assert (logical (fourier (diff (f (x), x), x, w) == -1i * w * fourier (f (x), x, w))) failed +5 tests, 4 passed, 1 known failure, 0 skipped +[inst/@sym/double.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/double.m ***** test - y = sym(11)/10; - t = sym(2); - x = 1.1; - s = 2; - A = chebyshevT (s, x); - B = double (chebyshevT (t, y)); - assert (A, B, -2*eps); + % numeric scalar + a = double(sym(10)); + assert (a == 10) + assert (isa (a, 'double')) ***** test - % maple - A = -0.304681164165948269030369; - B = chebyshevT (18.1, 0.9); - assert (A, B, -10*eps) + % numeric vectors + a = double(sym([10 12])); + assert (isequal (a, [10 12])) + assert (isa (a, 'double')) ***** test - % maple, complex inputs - % ChebyshevT(12.1+3.1*I, 0.5+0.2*I); - A = 0.637229289490379273451 - 0.475324703778957991318*1i; - B = chebyshevT (12.1+3.1*i, 0.5+0.2i); - assert (A, B, -5*eps); + % complex + a = 3 + 4i; + b = sym(a); + assert (isequal (double (b), a)) +***** xtest + % unexpected, precisely same floating point + a = 3 + 4i; + b = sym(a); + assert (isequal (double (b/pi), a/pi)) ***** test - % maple, matrix inputs - A = [0.59523064198266880000 0.57727442996887552000]; - B = chebyshevT ([16 17], [0.9 0.7]); - assert (A, B, -10*eps); + % floating point + x = sqrt(sym(2)); + assert( abs(double(x) - sqrt(2)) < 2*eps) + x = sym(pi); + assert( abs(double(x) - pi) < 2*eps) ***** test - % x matrix, s scalar - y = [1 2 sym(pi); exp(sym(1)) 5 6]; - t = sym(2); - x = double (y); - s = 2; - A = chebyshevT (s, x); - B = double (chebyshevT (t, y)); - assert (A, B, -eps); + oo = sym(inf); + assert( double(oo) == inf ) + assert( double(-oo) == -inf ) + assert( isnan(double(0*oo)) ) ***** test - % s matrix, x scalar - t = [1 2 sym(pi); exp(sym(1)) 5 6]; - y = sym(2); - s = double (t); - x = 2; - A = chebyshevT (s, x); - B = double (chebyshevT (t, y)); - assert (A, B, -eps); -***** xtest - % https://github.com/fredrik-johansson/mpmath/issues/469 - assert (chebyshevT (4, inf), inf) - assert (chebyshevT (4, -inf), inf) - assert (chebyshevT (3, inf), inf) - assert (chebyshevT (3, -inf), -inf) -!!!!! known failure -ASSERT errors for: assert (chebyshevT (4, inf),inf) - - Location | Observed | Expected | Reason - () 1 Inf 'Inf' mismatch -11 tests, 10 passed, 1 known failure, 0 skipped -[inst/@double/cosint.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/cosint.m -***** error cosint (1, 2) + zoo = sym('zoo'); + assert (double(zoo) == complex(inf, inf)) ***** test - x = 1.1; - y = sym(11)/10; - A = cosint (x); - B = double (cosint (y)); - assert (A, B, -4*eps); + zoo = sym('zoo'); + assert (double(-zoo) == double(zoo) ) + assert( isnan(double(0*zoo)) ) ***** test - y = [2 3 sym(pi); exp(sym(1)) 5 6]; - x = double (y); - A = cosint (x); - B = double (cosint (y)); - assert (A, B, -4*eps); + % nan + snan = sym(nan); + assert( isnan(double(snan))) ***** test - % maple: - % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; - % > for a in A do evalf(Ci(a)) end do; - x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; - A = [ 2.0302963932917216378 - 0.15190715517585688438*1i - 1.6153896382910774851 + 19.725754055338264980*1i - -0.0051488251426104921444 - 1246.1144860424544147 + 1.5707963267948966192*1i - -8.6330747120742332203 + 3.1315929869531280002*1i - 0.069822228467306149311 - 3.1184744625477294643*1i ]; - B = cosint (x); - assert (A, B, -eps) -***** xtest - % is it nan or -inf? SymPy says zoo. - assert (isnan (cosint (0))) -!!!!! known failure -assert (isnan (cosint (0))) failed -***** assert (cosint (inf), 0) -***** assert (cosint (-inf), pi*1i, -eps) -***** assert (cosint (1), 0.33740392290096813466, -eps) -***** assert (cosint (-1), 0.33740392290096813466 + pi*1i, -eps) -***** assert (cosint (pi), 0.073667912046425485978, -5*eps) -***** assert (cosint (-pi), 0.07366791204642548597821 + pi*1i, -5*eps) -***** assert (cosint (300), -3.3321999185921117800e-3, -2*eps) -***** assert (cosint (1e4), -3.0551916724485212665e-5, -2*eps) -***** assert (cosint (1 + 1i), 0.8821721805559363250506+0.2872491335199559395273*1i, eps) -***** assert (cosint (1i), 0.8378669409802082408947 + pi/2*1i, -2*eps) + % don't want NaN+NaNi + snan = sym(nan); + assert (isreal (double (snan))) ***** test - % compare both sinint and cosint to expint - x = pi; - C1 = cosint (x); - S1 = sinint (x); - R = expint (1i*x); - C2 = -real (R); - S2 = imag (R) + pi/2; - assert (C1, C2, -100*eps); - assert (S1, S2, -100*eps); -16 tests, 15 passed, 1 known failure, 0 skipped -[inst/@double/chebyshevU.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/chebyshevU.m -***** error chebyshevU (1) -***** error chebyshevU (1, 2, 3) -***** error chebyshevU ([1 2], [1 2 3]) -***** error chebyshevU ([1 2], [1; 2]) + % arrays + a = [1 2; 3 4]; + assert( isequal( double(sym(a)), a )) + assert( isequal( double(sym(a)), a )) + % should fail with error for non-double +***** error syms x; double(x) +***** error syms x; double([1 2 x]) +13 tests, 13 passed, 0 known failure, 0 skipped +[inst/@sym/eval.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/eval.m +***** error eval (sym(1), 2) +***** assert (isnumeric (eval (sym(3)))) +***** assert (isnumeric (eval (sin (sym(3))))) ***** test - y = sym(11)/10; - t = sym(2); - x = 1.1; - s = 2; - A = chebyshevU (s, x); - B = double (chebyshevU (t, y)); - assert (A, B, -2*eps); + syms x y + f = 2*x*y; + x = 3; + y = 4; + g = eval (f); + assert (isequal (g, 24)) ***** test - % maple - A = 1.661891066691338157; - B = chebyshevU (18.1, 0.9); - assert (A, B, -3*eps) + syms x y + f = 2*x*y; + clear y + x = 3; + g = eval (f); + assert (isequal (g, 6*sym('y'))) ***** test - % maple, complex inputs> - % ChebyshevU(12.1+3.1*I, 0.5+0.2*I); - A = 1.046959313670290818 - 0.03386773634958834846*1i; - B = chebyshevU (12.1+3.1*i, 0.5+0.2i); - assert (A, B, -3*eps); + % do not convert inputs to sym, for SMT compat + nearpi = pi + 1e-14; % sym could make this pi + x = sym('x'); + f = 2*x; + x = nearpi; + d = eval (f); + assert (abs (d - 2*pi) > 1e-15) +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@sym/bessely.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/bessely.m ***** test - % maple, matrix inputs - A = [2.2543638828875776000 -1.3872651600553574400]; - B = chebyshevU ([16 17], [0.9 0.8]); - assert (A, B, -10*eps); + X = [1 2 3; 4 5 6]; + ns = [sym(0) 1 -2; sym(1)/2 -sym(3)/2 pi]; + n = double(ns); + A = double(bessely(ns, X)); + B = bessely(n, X); + assert (all (all (abs (A - B) < 50*eps*abs(A)))) ***** test - % x matrix, s scalar - y = [1 2 sym(pi); exp(sym(1)) 5 6]; - t = sym(2); - x = double (y); - s = 2; - A = chebyshevU (s, x); - B = double (chebyshevU (t, y)); - assert (A, B, -eps); + % roundtrip + syms x + A = bessely(2, 10); + q = bessely(2, x); + h = function_handle(q); + B = h(10); + assert (abs (A - B) <= eps*abs(A)) +***** error bessely(sym('x')) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/ssinint.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/ssinint.m +***** assert (isequal (ssinint(sym(0)), -sym(pi)/2)) ***** test - % s matrix, x scalar - t = [1 2 sym(pi); exp(sym(1)) 5 6]; - y = sym(2); - s = double (t); - x = 2; - A = chebyshevU (s, x); - B = double (chebyshevU (t, y)); - assert (A, B, -2*eps); -***** xtest - % https://github.com/fredrik-johansson/mpmath/issues/469 - assert (chebyshevU (4, inf), inf) - assert (chebyshevU (4, -inf), inf) - assert (chebyshevU (3, inf), inf) - assert (chebyshevU (3, -inf), -inf) -!!!!! known failure -ASSERT errors for: assert (chebyshevU (4, inf),inf) - - Location | Observed | Expected | Reason - () 5 Inf 'Inf' mismatch -11 tests, 10 passed, 1 known failure, 0 skipped -[inst/@double/dilog.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/dilog.m + A = ssinint (sym ([0 1])); + B = [-pi/2 -0.62471325642771360426]; + assert( all(all( abs(double(A)-B) < 1e-15 ))) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@sym/acot.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/acot.m +***** error acot (sym(1), 2) +***** assert (isequaln (acot (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); ***** test - x = 1.1; - y = sym(11)/10; - A = dilog (x); - B = double (dilog (y)); - assert (A, B, -4*eps); + f1 = acot(x); + f2 = acot(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - y = [2 2 sym(pi); exp(sym(1)) 5 6]; - x = double (y); - A = dilog (x); - B = double (dilog (y)); - assert (A, B, -eps); + D = [d d; d d]; + A = [x x; x x]; + f1 = acot(A); + f2 = acot(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test - % maple: - % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; - % > for a in A do evalf(dilog(a)) end do; - x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; - A = [ -0.59248494924959145800 - 1.5760154034463234224*1i - -1.0549087538833908441 - 3.8759788000863368495*1i - -12.192421669033171348 - -2.9195729380904939394 - 3.9540920181102973073*1i - 1.6459519160623984119 - 0.00032335296277550987686*1i - -1.5445800511775466879 + 9.4256034277816069684*1i ]; - B = dilog (x); + % round trip + y = sym('y'); + A = acot (d); + f = acot (y); + h = function_handle (f); + B = h (d); assert (A, B, -eps) -***** xtest - % https://github.com/fredrik-johansson/mpmath/issues/473 - assert (isinf (dilog (inf))) -!!!!! known failure -assert (isinf (dilog (inf))) failed -***** assert (isnan (dilog (-inf))) -5 tests, 4 passed, 1 known failure, 0 skipped -[inst/@double/fresnelc.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/fresnelc.m -***** error fresnelc (1, 2) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/isequaln.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/isequaln.m ***** test - x = 1.1; - y = sym(11)/10; - A = fresnelc (x); - B = double (fresnelc (y)); - assert (A, B, -4*eps); + a = sym([1 2]); + b = a; + assert (isequaln (a, b)) + b(1) = 42; + assert (~isequaln (a, b)) ***** test - y = [2 3 sym(pi); exp(sym(1)) 5 6]; - x = double (y); - A = fresnelc (x); - B = double (fresnelc (y)); - assert (A, B, -4*eps); + a = sym([1 2; 3 4]); + b = a; + assert (isequaln (a, b)) + b(1) = 42; + assert (~isequaln (a, b)) ***** test - % maple: - % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; - % > for a in A do evalf(FresnelC(a)) end do; - x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; - A = [ 16.087871374125480424 - 36.225687992881650217*1i - 0.47688568479874574722e12 + 0.12213736710985573216e13*1i - 0.49999989867881789756 - 0.49989869420551572361*1i - -0.000099999999999999997535 + 0.99999999999999987665e-6*1i - 0.15391592966931193100e26 - 0.75738824160998910388e24*1i ]; - B = fresnelc (x); - assert (A, B, -eps) -***** assert (fresnelc (inf), 0.5) -***** assert (fresnelc (-inf), -0.5) -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@double/zeta.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/zeta.m -***** error zeta (1, 2, 3) -***** assert (isnan (zeta (nan))) + a = sym([nan; 2]); + b = a; + assert (isequaln (a, b)) ***** test - x = 1.1; - y = sym(11)/10; - A = zeta (x); - B = double (zeta (y)); - assert (A, B, -4*eps); + a = sym([nan 2; 3 4]); + b = a; + assert (isequaln (a, b)) ***** test - y = [2 3 sym(pi); exp(sym(1)) 5 6]; - x = double (y); - A = zeta (x); - B = double (zeta (y)); - assert (A, B, -4*eps); + % more than two arrays + a = sym([nan 2 3]); + b = a; + c = a; + assert (isequaln (a, b, c)) + c(1) = 42; + assert (~isequaln (a, b, c)) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/atan.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/atan.m +***** error atan (sym(1), 2) +***** assert (isequaln (atan (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); ***** test - % maple: - % > A := [1+2*I, -2 + 5*I, 100, 10*I, -1e-4 + 1e-6*I, -20 + I]; - % > for a in A do evalf(Zeta(a)) end do; - x = [1+2i; -2+5i; 100; 10i; -1e-4 + 1e-6*1i; -20-1i]; - A = [ 0.59816556976238173670 - 0.35185474521784529050*1i - 0.21425967567391921717 + 0.52503846985036050707*1i - 1.0 - 1.7564685929749629608 - 0.10151198543617116894*1i - -0.49990811617645824900 - 0.91873792757763831501e-6*1i - 175.09070083717643866 - 71.512541417467273425*1i ]; - B = zeta (x); - assert (A, B, -eps) -***** assert (zeta (inf), 1.0) -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@double/polylog.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@double/polylog.m -***** error polylog (1) -***** error polylog (1, 2, 3) -***** error polylog ([1 2], [1 2 3]) -***** error polylog ([1 2], [1; 2]) + f1 = atan(x); + f2 = atan(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - y = sym(11)/10; - t = sym(2); - x = 1.1; - s = 2; - A = polylog (s, x); - B = double (polylog (t, y)); - assert (A, B, -eps); + D = [d d; d d]; + A = [x x; x x]; + f1 = atan(A); + f2 = atan(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** test - % maple - A = 2.3201804233130983964 - 3.4513922952232026614*1i; - B = polylog (2, 3); + % round trip + y = sym('y'); + A = atan (d); + f = atan (y); + h = function_handle (f); + B = h (d); assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/hilb.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/hilb.m ***** test - % maple, complex inputs - A = -11.381456201167411758 + 6.2696695219721651947*1i; - B = polylog (1+2i, 3+4i); - assert (A, B, -eps); + A = hilb (sym(3)); + B = [sym(1) sym(1)/2 sym(1)/3; sym(1)/2 sym(1)/3 sym(1)/4; sym(1)/3 sym(1)/4 sym(1)/5]; + assert (isequal (A, B)) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@sym/igamma.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/igamma.m ***** test - % maple, matrix inputs - A1 = 0.47961557317612748431 - 0.52788287823025778869*1i; - A2 = -0.0049750526563452645369 - 0.024579343612396884851*1i; - B = polylog ([-1-2i -3], [30+40i 40i]); - assert ([A1 A2], B, -eps); + % mostly tested in @sym/gammainc + syms x + assert (isequal (igamma (2, x), gammainc(x, 2, 'upper'))) ***** test - % x matrix, s scalar - y = [1 2 sym(pi); exp(sym(1)) 5 6]; - t = sym(2); - x = double (y); - s = 2; - A = polylog (s, x); - B = double (polylog (t, y)); - assert (A, B, -eps); + % unregularized + B = double (igamma (sym(3), 1)); + A = gammainc (1, 3, 'upper')*gamma (3); + assert (A, B, -2*eps) ***** test - % s matrix, x scalar - t = [1 2 sym(pi); exp(sym(1)) 5 6]; - y = sym(2); - s = double (t); - x = 2; - A = polylog (s, x); - B = double (polylog (t, y)); - assert (A, B, -eps); -10 tests, 10 passed, 0 known failure, 0 skipped -[inst/assume.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/assume.m -***** error - a = assume('a', 'real') -***** error - assume positive integer -***** error - assume x y -***** error - assume x clear real -***** error - assume a>0 -***** error - assume 'x/pi' integer + % something like a round trip: no igamma() + syms x a + f = igamma (a, x); + h = function_handle (f, 'vars', [a x]); + A = h (1.1, 2.2); + B = double (igamma (sym(11)/10, sym(22)/10)); + C = gammainc (2.2, 1.1, 'upper')*gamma(1.1); + assert (A, B, -10*eps) + assert (A, C, -10*eps) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/@sym/airy.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/airy.m ***** 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')) + syms z + a = airy(0, z); + ap = airy(1, z); + assert (isequal (diff (a), ap)) + assert (isequal (diff (ap), z*a)) ***** test - % multiple assumptions - syms x - assume x positive integer - [tilde, a] = assumptions(x, 'dict'); - assert(a{1}.integer) - assert(a{1}.positive) + syms z + b = airy(2, z); + bp = airy(3, z); + assert (isequal (diff (b), bp)) + assert (isequal (diff (bp), z*b)) ***** 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 - % does not create new variable x - clear x - assume x real -***** error - % no explicit variable named x - clear x - f = 2*sym('x'); - assume x real + % default to k=0 + syms z + a = airy(0, z); + a2 = airy(z); + assert (isequal (a, a2)) +***** error airy(0, sym('x'), 2) +***** error airy(4, sym('z')) +***** error airy(-1, sym('z')) ***** test - % clear does workspace - syms x positive - f = 2*x; - assume x clear - assert (isempty (assumptions (f))); - assert (isempty (assumptions ())); + % symbolic k + syms z + b1 = airy(2, z); + b2 = airy(sym(2), z); + assert (isequal (b1, b2)) ***** 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')) + % doubles, relative error + X = [1 2 pi; 4i 5 6+6i]; + Xs = sym(X); + for k = 0:3 + A = double(airy(k, Xs)); + B = airy(k, X); + assert (all (all (abs(A - B) < 500*eps*abs(A)))) + end ***** 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')) + % round-trip + syms x + for k = 0:3 + A = airy(k, 10); + q = airy(k, x); + h = function_handle(q); + B = h(10); + assert (abs(A-B) < 500*eps*abs(A)) + end +9 tests, 9 passed, 0 known failure, 0 skipped +[inst/@sym/sqrt.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/sqrt.m +***** error sqrt (sym(1), 2) +***** assert (isequaln (sqrt (sym(nan)), sym(nan))) +***** shared x, d + d = 1; + x = sym('1'); ***** 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')) + f1 = sqrt(x); + f2 = sqrt(d); + assert( abs(double(f1) - f2) < 1e-15 ) ***** test - % works from variable names not symbols - y = sym('x'); - f = 2*y; - assume y real - assert (strcmp (assumptions (f), 'x: real')) + D = [d d; d d]; + A = [x x; x x]; + f1 = sqrt(A); + f2 = sqrt(D); + assert( all(all( abs(double(f1) - f2) < 1e-15 ))) ***** 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')) + % round trip + y = sym('y'); + A = sqrt (d); + f = sqrt (y); + h = function_handle (f); + B = h (d); + assert (A, B, -eps) +5 tests, 5 passed, 0 known failure, 0 skipped +[inst/@sym/log10.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@sym/log10.m +***** assert (isequal (log10 (sym (1000)), sym (3))) +***** assert (isequal (log10 (sym ([10 100])), sym ([1 2]))) ***** test - % assume after symfun - clear x - syms f(x) - assume x real - assert (~ isempty (assumptions (formula (f)))) - assert (~ isempty (assumptions (argnames (f)))) + % round-trip + syms x + f = log10 (x); + h = function_handle (f); + A = h (1.1); + B = log10 (1.1); + assert (A, B, -eps) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/eulergamma.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/eulergamma.m +***** error catalan (sym(1)) +***** assert (double (eulergamma ()) > 0.577215664901) +***** assert (double (eulergamma ()) < 0.577215664902) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/poly2sym.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/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 -[inst/findsymbols.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/findsymbols.m +[inst/@symfun/diff.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/diff.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])) + % concrete fcn + syms x + f(x) = x*x; + g(x) = 2*x; + assert (logical (diff(f) == g)) + assert (isa (diff(f), 'symfun')) +***** test + % abstract fcn + syms y(x) + assert (logical (diff(y) == diff(y(x)))) + assert (isa (diff(y), 'symfun')) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@symfun/rdivide.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/rdivide.m ***** test syms x - s = findsymbols (x); - assert (isequal (s{1}, x)) + f(x) = x^2; + assert( isa(f./f, 'symfun')) + assert( isa(f./[x x^2], 'symfun')) ***** 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))))) + syms x + f(x) = [x 2*x]; + h = f./[x 2]; + assert( isa(h, 'symfun')) + assert (isequal (formula (h), [1 x])) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@symfun/symvar.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/symvar.m ***** test - % empty sym for findsymbols, findsym, and symvar - assert (isempty (findsymbols (sym([])))) - assert (isempty (findsym (sym([])))) - assert (isempty (symvar (sym([])))) + % basic + syms f(t, s) + assert (isempty (symvar (f, 0))) + assert (isequal (symvar (f, 1), t)) + assert (isequal (symvar (f, 2), [t s])) + assert (isequal (symvar (f, 3), [t s])) ***** test - % diff. assumptions make diff. symbols - x1 = sym('x'); - x2 = sym('x', 'positive'); - f = x1*x2; - assert (length (findsymbols (f)) == 2) + % note preference for vars of symfun, if n requested + syms x f(y) + assert (isequal (symvar(f*x, 1), y)) + assert (isequal (symvar(f(y)*x, 1), x)) ***** test - % symfun or sym + % symfun, checked smt 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})) + assert (isequal (symvar(a), [x y])) + assert (isequal (symvar(b), [x 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])) + % preference for the explicit variables + syms a x f(t, s) + h = f*a + x; + assert (isequal (symvar (h, 1), t)) + assert (isequal (symvar (h, 2), [t s])) + assert (isequal (symvar (h, 3), [t s x])) + assert (isequal (symvar (h, 4), [t s x a])) + assert (isequal (symvar (h, 5), [t s x a])) + assert (isequal (symvar (h), [a s t x])) ***** 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})) + % symfun dep on some vars only, matches smt w/ n + syms x s t + f(s) = x; + g(s, t) = x*s; + assert (isequal (symvar(f, 1), s)) + assert (isequal (symvar(f, 2), [s x])) + assert (isequal (symvar(g, 1), s)) + assert (isequal (symvar(g, 2), [s t])) + assert (isequal (symvar(g, 3), [s t x])) ***** test - % array of eq - syms x y - assert (isequal (findsymbols (2 == [2 x y]), {x y})) + % A documented difference from SMT on symvar(symfun) w/o n + syms x s t + f(s) = x; + g(s, t) = x*s; + % SMT would have + %assert (isequal (symvar(f), x)) % no s + %assert (isequal (symvar(g), [s x])) % no t + assert (isequal (symvar(f), [s x])) + assert (isequal (symvar(g), [s t x])) +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@symfun/mldivide.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/mldivide.m ***** 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/octsympy_tests.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/octsympy_tests.m -***** assert(true) + syms x + f(x) = x^2; + assert( isa(f\f, 'symfun')) + assert( isa(f\x, 'symfun')) 1 test, 1 passed, 0 known failure, 0 skipped -[inst/@logical/isAlways.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@logical/isAlways.m -***** error isAlways (true, false) -***** assert(isAlways(true)) -***** assert(~isAlways(false)) +[inst/@symfun/formula.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/formula.m +***** test + % simple + syms x + f(x) = sin(x); + g = formula(f); + assert (isequal (g, sin(x))); +***** test + % concrete: return is a sym, not a symfun + syms x + f(x) = sin(x); + g = formula(f); + assert (~isa(g, 'symfun')); +***** test + % abstract: return is a sym, not a symfun + syms f(x) + g = formula(f); + assert (~isa(g, 'symfun')); 3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@symfun/plus.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/plus.m +[inst/@symfun/ldivide.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/ldivide.m ***** test syms x f(x) = x^2; - assert( isa(f + f, 'symfun')) - assert( isa(f + x, 'symfun')) + assert( isa(f .\ f, 'symfun')) + assert( isa(f .\ x, 'symfun')) 1 test, 1 passed, 0 known failure, 0 skipped -[inst/@symfun/times.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/times.m +[inst/@symfun/argnames.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/argnames.m ***** test - syms x - f(x) = x^2; - assert( isa(f .* f, 'symfun')) - assert( isa(f .* x, 'symfun')) + % basic test + syms f(x) + assert (isequal (argnames (f), x)) ***** test - syms x - f(x) = [x 2*x]; - h = f.*[x 3]; - assert( isa(h, 'symfun')) - assert (isequal (formula (h), [x^2 6*x])) -2 tests, 2 passed, 0 known failure, 0 skipped + % Multiple variables, abstract symfun + syms f(t, x, y) + assert (isequal (argnames (f), [t x y])) +***** test + % Concrete symfun + syms x y z t + f(t, x, y) = x + y + z; + assert (isequal (argnames (f), [t x y])) +3 tests, 3 passed, 0 known failure, 0 skipped [inst/@symfun/isequal.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/isequal.m ***** error isequal (symfun('x + 1', x)) @@ -15509,6 +15154,116 @@ g(x) = symfun(nan, x); assert (~ isequal (f, g)) 6 tests, 6 passed, 0 known failure, 0 skipped +[inst/@symfun/mpower.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/mpower.m +***** test + syms x + f(x) = 2*x; + h = f^f; + assert( isa(h, 'symfun')) + assert (isequal (formula (h), (2*x)^(2*x))) + h = f^sym(2); + assert( isa(h, 'symfun')) + assert (isequal (formula (h), 4*x^2)) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@symfun/int.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/int.m +***** test + % indefinite integral of symfun gives symfun + syms x + f(x) = x^2; + g = int(f); + assert (isa(g, 'symfun')) + g = int(f, x); + assert (isa(g, 'symfun')) +***** test + % indefinite integral of abstract symfun gives symfun + syms f(x) + g = int(f); + assert (isa(g, 'symfun')) + g = int(f, x); + assert (isa(g, 'symfun')) +***** test + % definite integral does not give symfun + syms x + f(x) = x^2; + g = int(f, x, 0, 2); + assert (isa(g, 'sym')) + assert (~isa(g, 'symfun')) +***** test + % ... even if it has a variable in it + syms x t + f(x) = x; + g = int(f, x, 0, t); + assert (isa(g, 'sym')) + assert (~isa(g, 'symfun')) +***** test + % ... even if the input is abstract function + syms f(x) + g = int(f, x, 0, 2); + assert (isa(g, 'sym')) + assert (~isa(g, 'symfun')) +***** test + % symfun in x, integrated in y gives symfun still in x + % (SMT does this too). + syms f(x) y + g = int(f, y); + assert (isa (g, 'symfun')) + assert (isequal (argnames (g), x)) +***** test + % same as above, but concrete symfun + syms x y + f(x) = x^2; + g = int(f, y); + assert (isa (g, 'symfun')) + assert (isequal (argnames (g), x)) + assert (isequal (formula(g), x^2*y)) +7 tests, 7 passed, 0 known failure, 0 skipped +[inst/@symfun/plus.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/plus.m +***** test + syms x + f(x) = x^2; + assert( isa(f + f, 'symfun')) + assert( isa(f + x, 'symfun')) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@symfun/times.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/times.m +***** test + syms x + f(x) = x^2; + assert( isa(f .* f, 'symfun')) + assert( isa(f .* x, 'symfun')) +***** test + syms x + f(x) = [x 2*x]; + h = f.*[x 3]; + assert( isa(h, 'symfun')) + assert (isequal (formula (h), [x^2 6*x])) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@symfun/mtimes.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/mtimes.m +***** test + syms x + f(x) = x^2; + assert( isa(f * f, 'symfun')) + assert( isa(f * x, 'symfun')) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/@symfun/private_disp_name.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/private_disp_name.m +***** test + syms f(x) + s = private_disp_name(f, 'f'); + assert (strcmp (s, 'f(x)')) +***** test + syms x y + g(y, x) = x + y; + s = private_disp_name(g, 'g'); + assert (strcmp (s, 'g(y, x)')) +***** test + syms f(x) + assert (isempty (private_disp_name(f, ''))) +3 tests, 3 passed, 0 known failure, 0 skipped [inst/@symfun/minus.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/minus.m ***** test @@ -15553,18 +15308,33 @@ assert( isequal (argnames (h), argnames (f))) assert (isequal (formula (h), 2*x*y - sin(y) + sin(x))) 4 tests, 4 passed, 0 known failure, 0 skipped -[inst/@symfun/mpower.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/mpower.m +[inst/@symfun/uminus.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/uminus.m +***** test + % Issue #447 + syms x + f(x) = x^2; + assert (isa (-f, 'symfun')) +***** test + syms f(x) + h = -f; + assert (isa (h, 'symfun')) +2 tests, 2 passed, 0 known failure, 0 skipped +[inst/@symfun/power.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/power.m ***** test syms x f(x) = 2*x; - h = f^f; + h = f.^f; assert( isa(h, 'symfun')) assert (isequal (formula (h), (2*x)^(2*x))) - h = f^sym(2); +***** test + syms x + f(x) = [x 2*x]; + h = f.^[x 3]; assert( isa(h, 'symfun')) - assert (isequal (formula (h), 4*x^2)) -1 test, 1 passed, 0 known failure, 0 skipped + assert (isequal (formula (h), [x^x 8*x^3])) +2 tests, 2 passed, 0 known failure, 0 skipped [inst/@symfun/numel.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/numel.m ***** test @@ -15597,33 +15367,29 @@ assert (size(f, 1) == 1) assert (size(f, 2) == 1) 2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@symfun/mldivide.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/mldivide.m +[inst/@symfun/subsref.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/subsref.m ***** test syms x f(x) = x^2; - assert( isa(f\f, 'symfun')) - assert( isa(f\x, 'symfun')) -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@symfun/uminus.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/uminus.m + v = f.vars; + assert(iscell(v)) + assert(length(v)==1) + assert(isequal(v{1},x)) ***** test - % Issue #447 + %% pass through to sym properties syms x f(x) = x^2; - assert (isa (-f, 'symfun')) -***** test - syms f(x) - h = -f; - assert (isa (h, 'symfun')) + y = x^2; % not a symfun + assert(strcmp(f.flat, y.flat)) 2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@symfun/mtimes.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/mtimes.m +[inst/@symfun/mrdivide.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/mrdivide.m ***** test syms x f(x) = x^2; - assert( isa(f * f, 'symfun')) - assert( isa(f * x, 'symfun')) + assert( isa(f/f, 'symfun')) + assert( isa(f/x, 'symfun')) 1 test, 1 passed, 0 known failure, 0 skipped [inst/@symfun/symfun.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/symfun.m @@ -15783,207 +15549,6 @@ syms x f(2*x) = 4*x; 25 tests, 25 passed, 0 known failure, 0 skipped -[inst/@symfun/diff.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/diff.m -***** test - % concrete fcn - syms x - f(x) = x*x; - g(x) = 2*x; - assert (logical (diff(f) == g)) - assert (isa (diff(f), 'symfun')) -***** test - % abstract fcn - syms y(x) - assert (logical (diff(y) == diff(y(x)))) - assert (isa (diff(y), 'symfun')) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@symfun/rdivide.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/rdivide.m -***** test - syms x - f(x) = x^2; - assert( isa(f./f, 'symfun')) - assert( isa(f./[x x^2], 'symfun')) -***** test - syms x - f(x) = [x 2*x]; - h = f./[x 2]; - assert( isa(h, 'symfun')) - assert (isequal (formula (h), [1 x])) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@symfun/ldivide.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/ldivide.m -***** test - syms x - f(x) = x^2; - assert( isa(f .\ f, 'symfun')) - assert( isa(f .\ x, 'symfun')) -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@symfun/int.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/int.m -***** test - % indefinite integral of symfun gives symfun - syms x - f(x) = x^2; - g = int(f); - assert (isa(g, 'symfun')) - g = int(f, x); - assert (isa(g, 'symfun')) -***** test - % indefinite integral of abstract symfun gives symfun - syms f(x) - g = int(f); - assert (isa(g, 'symfun')) - g = int(f, x); - assert (isa(g, 'symfun')) -***** test - % definite integral does not give symfun - syms x - f(x) = x^2; - g = int(f, x, 0, 2); - assert (isa(g, 'sym')) - assert (~isa(g, 'symfun')) -***** test - % ... even if it has a variable in it - syms x t - f(x) = x; - g = int(f, x, 0, t); - assert (isa(g, 'sym')) - assert (~isa(g, 'symfun')) -***** test - % ... even if the input is abstract function - syms f(x) - g = int(f, x, 0, 2); - assert (isa(g, 'sym')) - assert (~isa(g, 'symfun')) -***** test - % symfun in x, integrated in y gives symfun still in x - % (SMT does this too). - syms f(x) y - g = int(f, y); - assert (isa (g, 'symfun')) - assert (isequal (argnames (g), x)) -***** test - % same as above, but concrete symfun - syms x y - f(x) = x^2; - g = int(f, y); - assert (isa (g, 'symfun')) - assert (isequal (argnames (g), x)) - assert (isequal (formula(g), x^2*y)) -7 tests, 7 passed, 0 known failure, 0 skipped -[inst/@symfun/mrdivide.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/mrdivide.m -***** test - syms x - f(x) = x^2; - assert( isa(f/f, 'symfun')) - assert( isa(f/x, 'symfun')) -1 test, 1 passed, 0 known failure, 0 skipped -[inst/@symfun/argnames.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/argnames.m -***** test - % basic test - syms f(x) - assert (isequal (argnames (f), x)) -***** test - % Multiple variables, abstract symfun - syms f(t, x, y) - assert (isequal (argnames (f), [t x y])) -***** test - % Concrete symfun - syms x y z t - f(t, x, y) = x + y + z; - assert (isequal (argnames (f), [t x y])) -3 tests, 3 passed, 0 known failure, 0 skipped -[inst/@symfun/power.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/power.m -***** test - syms x - f(x) = 2*x; - h = f.^f; - assert( isa(h, 'symfun')) - assert (isequal (formula (h), (2*x)^(2*x))) -***** test - syms x - f(x) = [x 2*x]; - h = f.^[x 3]; - assert( isa(h, 'symfun')) - assert (isequal (formula (h), [x^x 8*x^3])) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@symfun/symvar.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/symvar.m -***** test - % basic - syms f(t, s) - assert (isempty (symvar (f, 0))) - assert (isequal (symvar (f, 1), t)) - assert (isequal (symvar (f, 2), [t s])) - assert (isequal (symvar (f, 3), [t s])) -***** test - % note preference for vars of symfun, if n requested - syms x f(y) - assert (isequal (symvar(f*x, 1), y)) - assert (isequal (symvar(f(y)*x, 1), x)) -***** test - % symfun, checked smt - syms x f(y) - a = f*x; - b = f(y)*x; - assert (isequal (symvar(a), [x y])) - assert (isequal (symvar(b), [x y])) -***** test - % preference for the explicit variables - syms a x f(t, s) - h = f*a + x; - assert (isequal (symvar (h, 1), t)) - assert (isequal (symvar (h, 2), [t s])) - assert (isequal (symvar (h, 3), [t s x])) - assert (isequal (symvar (h, 4), [t s x a])) - assert (isequal (symvar (h, 5), [t s x a])) - assert (isequal (symvar (h), [a s t x])) -***** test - % symfun dep on some vars only, matches smt w/ n - syms x s t - f(s) = x; - g(s, t) = x*s; - assert (isequal (symvar(f, 1), s)) - assert (isequal (symvar(f, 2), [s x])) - assert (isequal (symvar(g, 1), s)) - assert (isequal (symvar(g, 2), [s t])) - assert (isequal (symvar(g, 3), [s t x])) -***** test - % A documented difference from SMT on symvar(symfun) w/o n - syms x s t - f(s) = x; - g(s, t) = x*s; - % SMT would have - %assert (isequal (symvar(f), x)) % no s - %assert (isequal (symvar(g), [s x])) % no t - assert (isequal (symvar(f), [s x])) - assert (isequal (symvar(g), [s t x])) -6 tests, 6 passed, 0 known failure, 0 skipped -[inst/@symfun/formula.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/formula.m -***** test - % simple - syms x - f(x) = sin(x); - g = formula(f); - assert (isequal (g, sin(x))); -***** test - % concrete: return is a sym, not a symfun - syms x - f(x) = sin(x); - g = formula(f); - assert (~isa(g, 'symfun')); -***** test - % abstract: return is a sym, not a symfun - syms f(x) - g = formula(f); - assert (~isa(g, 'symfun')); -3 tests, 3 passed, 0 known failure, 0 skipped [inst/@symfun/isequaln.m] >>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/isequaln.m ***** error isequaln (symfun('x + 1', x)) @@ -16020,37 +15585,508 @@ g(x, y) = symfun(nan, x); assert (~ isequaln (f, g)) 7 tests, 7 passed, 0 known failure, 0 skipped -[inst/@symfun/subsref.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/subsref.m +[inst/assume.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/assume.m +***** error + a = assume('a', 'real') +***** error + assume positive integer +***** error + assume x y +***** error + assume x clear real +***** error + assume a>0 +***** error + assume 'x/pi' integer ***** test syms x - f(x) = x^2; - v = f.vars; - assert(iscell(v)) - assert(length(v)==1) - assert(isequal(v{1},x)) + assume x positive + a = assumptions(x); + assert(strcmp(a, 'x: positive')) + assume x even + a = assumptions(x); + assert(strcmp(a, 'x: even')) ***** test - %% pass through to sym properties + % multiple assumptions syms x - f(x) = x^2; - y = x^2; % not a symfun - assert(strcmp(f.flat, y.flat)) -2 tests, 2 passed, 0 known failure, 0 skipped -[inst/@symfun/private_disp_name.m] ->>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/@symfun/private_disp_name.m + assume x positive integer + [tilde, a] = assumptions(x, 'dict'); + assert(a{1}.integer) + assert(a{1}.positive) ***** test - syms f(x) - s = private_disp_name(f, 'f'); - assert (strcmp (s, 'f(x)')) + % 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 + % does not create new variable x + clear x + assume x real +***** error + % 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 - g(y, x) = x + y; - s = private_disp_name(g, 'g'); - assert (strcmp (s, 'g(y, x)')) + 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) - assert (isempty (private_disp_name(f, ''))) + assume x real + assert (~ isempty (assumptions (formula (f)))) + assert (~ isempty (assumptions (argnames (f)))) +18 tests, 18 passed, 0 known failure, 0 skipped +[inst/octsympy_tests.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/octsympy_tests.m +***** assert(true) +1 test, 1 passed, 0 known failure, 0 skipped +[inst/laguerreL.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/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 laguerreL(1.5, 10) +***** error laguerreL([0 1], [1 2 3]) +***** error 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/catalan.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/catalan.m +***** error catalan (sym(1)) +***** assert (double (catalan ()) > 0.915965594177) +***** assert (double (catalan ()) < 0.915965594178) +3 tests, 3 passed, 0 known failure, 0 skipped +[inst/fibonacci.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/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] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/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] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/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/heaviside.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/heaviside.m +***** assert (heaviside (0) == 0.5) +***** assert (isnan (heaviside (nan))) +***** assert (isequal (heaviside ([-inf -eps 0 eps inf]), [0 0 0.5 1 1])) +***** assert (isequaln (heaviside ([-1 1 nan]), [0 1 nan])) +***** assert (heaviside (0, 1) == 1) +***** error heaviside (1i) +***** assert (isa (heaviside (single (0)), 'single')) +7 tests, 7 passed, 0 known failure, 0 skipped +[inst/dirac.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/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 dirac (1i) +***** assert (isa (dirac (single (0)), 'single')) +6 tests, 6 passed, 0 known failure, 0 skipped +[inst/vpa.m] +>>>>> /build/reproducible-path/octave-symbolic-3.2.1/inst/vpa.m +***** test + a = vpa(0, 4); + b = double(a); + assert(b == 0) +***** test + a = vpa(pi, 4); + b = sin(a); + assert(abs(double(b)) < 1e-4) +***** test + % vpa from double is ok, doesn't warn (c.f., sym(2.3)) + a = vpa(2.3); + assert(true) +***** test + % vpa from double not more than 16 digits + a = vpa(sqrt(pi), 32); + b = sin(a^2); + assert(abs(double(b)) > 1e-20) + assert(abs(double(b)) < 1e-15) +***** test + a = vpa(sym(pi), 32); + b = sin(a); + assert(abs(double(b)) < 1e-30) +***** test + a = vpa(sym(pi), 256); + b = sin(a); + assert(abs(double(b)) < 1e-256) +***** test + % pi str + a = vpa('pi', 32); + b = sin(a); + assert(abs(double(b)) < 1e-32) +***** test + % pi str + a = vpa('pi', 32); + b = vpa(sym('pi'), 32); + assert (double (a - b) == 0) +***** test + spi = sym(pi); + a = vpa(spi, 10); + b = double(a); + assert(~isAlways(spi == a)) +***** test + % matrix of sym + a = [sym(pi) 0; sym(1)/2 1]; + b = [pi 0; 0.5 1]; + c = vpa(a, 6); + assert(max(max(abs(double(c)-b))) < 1e-6) +***** test + % matrix of double + b = [pi 0; 0.5 1]; + c = vpa(b, 6); + assert(max(max(abs(double(c)-b))) < 1e-6) +***** test + % integer type + a = vpa(int32(6), 64); + b = vpa(6, 64); + assert (isequal (a, b)) +***** test + % matrix of int + b = int32([pi 0; 6.25 1]); + c = vpa(b, 6); + assert (isequal (double(c), [3 0; 6 1])) +***** test + % can pass pi directly to vpa + a = vpa(sym(pi), 128); + b = vpa(pi, 128); + assert (isequal (a, b)) +***** test + % if sym does sth special for e so should vpa + a = vpa(sym(exp(1)), 64); + b = vpa(exp(1), 64); + assert (isequal (a, b)) +***** test + % can pass pi directly to vpa, even in array + a = vpa(sym([2 pi]), 128); + b = vpa([2 pi], 128); + assert (isequal (a, b)) +***** test + % can pass i directly to vpa + a = vpa(sym(i)); + b = vpa(i); +***** test + % 'i' and 'I' just make vars + a = vpa(sym(1i)); + b = vpa('i'); + c = vpa('I'); + assert (~isequal (a, b)) + assert (~isequal (a, c)) +***** test + % '1i' and '1j' strings + a = vpa(sym(1i)); + b = vpa('1i'); + c = vpa('1j'); + assert (isequal (a, b)) + assert (isequal (a, c)) +***** test + % Issue #868, precision loss on '0.33j' + a = vpa('0.33j', 40); + b = vpa('0.33i', 40); + assert (double (abs (imag (a)*100/33) - 1) < 1e-39) + assert (isequal (a, b)) +***** test + % inf/-inf do not become symbol('inf') + S = {'oo', '-oo', 'inf', 'Inf', '-inf', '+inf'}; + for j = 1:length(S) + a = vpa(S{j}); + b = vpa(sym(S{j})); + assert (isequal (a, b)) + end +***** test + a = vpa('2.3', 20); + s = strtrim(disp(a, 'flat')); + assert (strcmp (s, '2.3000000000000000000')) +***** test + % these should *not* be the same + a = vpa(2.3, 40); + b = vpa('2.3', 40); + sa = sympy (a); + sb = sympy (b); + assert (~isequal (a, b)) + assert (abs(double(a - b)) > 1e-20) + assert (abs(double(a - b)) < 1e-15) + assert (~strcmp(sa, sb)) +***** test + % these should *not* be the same + x = vpa('1/3', 32); + y = vpa(sym(1)/3, 32); + z = vpa(1/3, 32); + assert (isequal (x, y)) + assert (~isequal (x, z)) +***** test + % big integers + a = int64(12345678); + a = a*a; + b = vpa(a); + c = vpa('152415765279684'); + assert (isequal (b, c)) +***** test + % big integers (workaround poor num2str, works in 4.0?) + a = int64(1234567891); a = a*a; + b = vpa(a); + c = vpa('1524157877488187881'); + assert (isequal (b, c)) +***** test + % isequal and other comparisons + a = vpa ("2/3", 32); + b = vpa ("2/3", 64); + assert (~ logical (a == b)) + assert (~ isequal (a, b)) + a = vpa ("1/3", 32); + b = vpa ("1/3", 64); + assert (~ logical (a == b)) + assert (~ isequal (a, b)) + a = vpa ("0.1", 32); + b = vpa ("0.1", 64); + assert (~ logical (a == b)) + assert (~ isequal (a, b)) +***** test + % isequal with array: Issue #1285 + a = vpa ("2/3", 32); + b = vpa ("2/3", 64); + assert (~ isequal ([a 2*a], [b 2*b])) +***** xtest + % non-equality of vpa that "might be" be integers: Issue #1285 + a = vpa ("123", 32); + b = vpa ("123", 64); + assert (~ logical (a == b)) +!!!!! known failure +assert (!logical (a == b)) failed +***** xtest + % non-equality of vpa that "might be" be integers: Issue #1285 + if (pycall_sympy__ ('return Version(spver) >= Version("1.12.1")')) + a = vpa ("123", 32); + b = vpa ("123", 64); + assert (~ isequal (a, b)) + end +***** warning vpa ('sqrt(2.0)'); +***** warning + a = vpa('2**0.5'); + b = vpa(sqrt(sym(2))); + assert (isequal (a, b)) +***** test + a = vpa('2.3e1'); + b = vpa(' 2.3e+1 '); + assert (isequal (a, b)) + a = vpa('21e-1'); + b = vpa('2.1'); + assert (isequal (a, b)) +***** test + % Issue #859, operations on immutable matrices + x = vpa (sym ([1 2])); + % If vpa no longer makes an ImmutableDenseMatrix, + % may need to adjust or remove this test. + assert (~ isempty (strfind (sympy (x), 'Immutable'))) + y = sin(x); + y2 = [sin(vpa(sym(1))) sin(vpa(sym(2)))]; + assert (isequal (y, y2)) +34 tests, 33 passed, 1 known failure, 0 skipped Checking C++ files ... Done running the unit tests. @@ -16079,12 +16115,14 @@ dpkg-buildpackage: info: binary-only upload (no source included) dpkg-genchanges: info: not including original source code in upload I: copying local configuration +I: user script /srv/workspace/pbuilder/58132/tmp/hooks/B01_cleanup starting +I: user script /srv/workspace/pbuilder/58132/tmp/hooks/B01_cleanup finished I: unmounting dev/ptmx filesystem I: unmounting dev/pts filesystem I: unmounting dev/shm filesystem I: unmounting proc filesystem I: unmounting sys filesystem I: cleaning the build env -I: removing directory /srv/workspace/pbuilder/17719 and its subdirectories -I: Current time: Sun Dec 14 12:58:58 -12 2025 -I: pbuilder-time-stamp: 1765760338 +I: removing directory /srv/workspace/pbuilder/58132 and its subdirectories +I: Current time: Tue Nov 12 08:59:06 +14 2024 +I: pbuilder-time-stamp: 1731351546