Mercurial > octave
comparison libinterp/corefcn/cellfun.cc @ 30346:91c6288781ba
maint: Shorten some long lines in libinterp to <= 80 characters (bug #57599)
* __isprimelarge__.cc, bsxfun.cc, cellfun.cc, chol.cc, data.cc, error.h,
event-manager.h, filter.cc, find.cc, gcd.cc, gl-render.h, gl2ps-print.cc,
graphics.cc, graphics.in.h, hash.cc, help.cc, hex2num.cc, input.cc, inv.cc,
load-path.cc, load-save.cc, ls-hdf5.cc, ls-hdf5.h, ls-mat5.cc, lu.cc,
mappers.cc, matrix_type.cc, max.cc, mex.cc, mxarray.h, oct-errno.in.cc,
oct-map.cc, oct-stream.cc, oct-stream.h, pr-output.cc, psi.cc, qr.cc, rand.cc,
regexp.cc, sparse-xdiv.h, stack-frame.cc, strfind.cc, strfns.cc, sylvester.cc,
symbfact.cc, symrec.h, symscope.cc, typecast.cc, utils.cc, variables.h, xdiv.h,
xpow.h, __init_fltk__.cc, __ode15__.cc, audiodevinfo.cc, audioread.cc,
convhulln.cc, cdef-class.cc, cdef-class.h, cdef-manager.cc, cdef-method.cc,
cdef-object.cc, cdef-object.h, cdef-package.h, cdef-utils.cc, ov-base-diag.cc,
ov-base-int.cc, ov-base.h, ov-bool-mat.cc, ov-bool.cc, ov-cell.cc,
ov-ch-mat.cc, ov-class.cc, ov-class.h, ov-classdef.cc, ov-colon.h,
ov-complex.cc, ov-cx-mat.cc, ov-cx-sparse.cc, ov-dld-fcn.h, ov-fcn-handle.cc,
ov-float.cc, ov-flt-complex.cc, ov-flt-cx-diag.cc, ov-flt-cx-mat.cc,
ov-flt-re-diag.cc, ov-flt-re-mat.cc, ov-java.cc, ov-lazy-idx.cc, ov-lazy-idx.h,
ov-range.cc, ov-re-mat.cc, ov-re-mat.h, ov-re-sparse.cc, ov-scalar.cc,
ov-str-mat.cc, ov-struct.cc, ov-typeinfo.cc, ov.cc, ov.h, octave.h,
bp-table.cc, bp-table.h, lex.h, oct-lvalue.h, profiler.cc, profiler.h,
pt-binop.h, pt-colon.cc, pt-eval.cc, pt-exp.h, pt-select.h:
Shorten some long lines in libinterp to <= 80 characters.
author | Rik <rik@octave.org> |
---|---|
date | Wed, 24 Nov 2021 09:38:51 -0800 |
parents | f69f749aad9b |
children | fe6d1711feea |
comparison
equal
deleted
inserted
replaced
30345:ba03a127bee1 | 30346:91c6288781ba |
---|---|
857 %! assert (isequal (C, {10, 11; [], 12})); | 857 %! assert (isequal (C, {10, 11; [], 12})); |
858 %!test | 858 %!test |
859 %! A = cellfun (@(x,y) cell2str (x,y), {1.1, 4}, {3.1, 6}, ... | 859 %! A = cellfun (@(x,y) cell2str (x,y), {1.1, 4}, {3.1, 6}, ... |
860 %! "ErrorHandler", @__cellfunerror); | 860 %! "ErrorHandler", @__cellfunerror); |
861 %! B = isfield (A(1), "message") && isfield (A(1), "index"); | 861 %! B = isfield (A(1), "message") && isfield (A(1), "index"); |
862 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]); | 862 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], |
863 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]); | 863 %! [true, true]); |
864 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]); | 864 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], |
865 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]); | 865 %! [true, true]); |
866 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], | |
867 %! [true, true]); | |
868 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], | |
869 %! [false, false]); | |
866 %! assert ([A(1).index, A(2).index], [1, 2]); | 870 %! assert ([A(1).index, A(2).index], [1, 2]); |
867 %!test # Overwriting setting of "UniformOutput" true | 871 %!test # Overwriting setting of "UniformOutput" true |
868 %! A = cellfun (@(x,y) cell2str (x,y), {1.1, 4}, {3.1, 6}, ... | 872 %! A = cellfun (@(x,y) cell2str (x,y), {1.1, 4}, {3.1, 6}, ... |
869 %! "UniformOutput", true, "ErrorHandler", @__cellfunerror); | 873 %! "UniformOutput", true, "ErrorHandler", @__cellfunerror); |
870 %! B = isfield (A(1), "message") && isfield (A(1), "index"); | 874 %! B = isfield (A(1), "message") && isfield (A(1), "index"); |
871 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]); | 875 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], |
872 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]); | 876 %! [true, true]); |
873 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]); | 877 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], |
874 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]); | 878 %! [true, true]); |
879 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], | |
880 %! [true, true]); | |
881 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], | |
882 %! [false, false]); | |
875 %! assert ([A(1).index, A(2).index], [1, 2]); | 883 %! assert ([A(1).index, A(2).index], [1, 2]); |
876 | 884 |
877 ## Input arguments can be of type cell arrays of character or strings | 885 ## Input arguments can be of type cell arrays of character or strings |
878 %!error # "UniformOutput" false should be used | 886 %!error # "UniformOutput" false should be used |
879 %! A = cellfun (@(x,y) x>y, {"ad", "c", "ghi"}, {"cc", "d", "fgh"}); | 887 %! A = cellfun (@(x,y) x>y, {"ad", "c", "ghi"}, {"cc", "d", "fgh"}); |
884 %! A = cellfun (@(x,y) x:y, {"a", "d"}, {"c", "f"}, "UniformOutput", false); | 892 %! A = cellfun (@(x,y) x:y, {"a", "d"}, {"c", "f"}, "UniformOutput", false); |
885 %! assert (A, {"abc", "def"}); | 893 %! assert (A, {"abc", "def"}); |
886 %!test | 894 %!test |
887 %! A = cellfun (@(x,y) cell2str (x,y), {"a", "d"}, {"c", "f"}, ... | 895 %! A = cellfun (@(x,y) cell2str (x,y), {"a", "d"}, {"c", "f"}, ... |
888 %! "ErrorHandler", @__cellfunerror); | 896 %! "ErrorHandler", @__cellfunerror); |
889 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]); | 897 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], |
890 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]); | 898 %! [true, true]); |
891 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]); | 899 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], |
892 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]); | 900 %! [true, true]); |
901 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], | |
902 %! [true, true]); | |
903 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], | |
904 %! [false, false]); | |
893 %! assert ([A(1).index, A(2).index], [1, 2]); | 905 %! assert ([A(1).index, A(2).index], [1, 2]); |
894 %!test # Overwriting setting of "UniformOutput" true | 906 %!test # Overwriting setting of "UniformOutput" true |
895 %! A = cellfun (@(x,y) cell2str (x,y), {"a", "d"}, {"c", "f"}, ... | 907 %! A = cellfun (@(x,y) cell2str (x,y), {"a", "d"}, {"c", "f"}, ... |
896 %! "UniformOutput", true, "ErrorHandler", @__cellfunerror); | 908 %! "UniformOutput", true, "ErrorHandler", @__cellfunerror); |
897 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]); | 909 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], |
898 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]); | 910 %! [true, true]); |
899 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]); | 911 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], |
900 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]); | 912 %! [true, true]); |
913 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], | |
914 %! [true, true]); | |
915 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], | |
916 %! [false, false]); | |
901 %! assert ([A(1).index, A(2).index], [1, 2]); | 917 %! assert ([A(1).index, A(2).index], [1, 2]); |
902 | 918 |
903 ## Structures cannot be handled by cellfun | 919 ## Structures cannot be handled by cellfun |
904 %!error | 920 %!error |
905 %! vst1.a = 1.1; vst1.b = 4.2; vst2.a = 3.1; vst2.b = 2; | 921 %! vst1.a = 1.1; vst1.b = 4.2; vst2.a = 3.1; vst2.b = 2; |
918 %! "UniformOutput", false); | 934 %! "UniformOutput", false); |
919 %! assert (A, {true, false}); | 935 %! assert (A, {true, false}); |
920 %!test | 936 %!test |
921 %! A = cellfun (@(x,y) mat2str (x,y), {{1.1}, {4.2}}, {{3.1}, {2}}, ... | 937 %! A = cellfun (@(x,y) mat2str (x,y), {{1.1}, {4.2}}, {{3.1}, {2}}, ... |
922 %! "ErrorHandler", @__cellfunerror); | 938 %! "ErrorHandler", @__cellfunerror); |
923 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]); | 939 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], |
924 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]); | 940 %! [true, true]); |
925 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]); | 941 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], |
926 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]); | 942 %! [true, true]); |
943 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], | |
944 %! [true, true]); | |
945 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], | |
946 %! [false, false]); | |
927 %! assert ([A(1).index, A(2).index], [1, 2]); | 947 %! assert ([A(1).index, A(2).index], [1, 2]); |
928 %!test # Overwriting setting of "UniformOutput" true | 948 %!test # Overwriting setting of "UniformOutput" true |
929 %! A = cellfun (@(x,y) mat2str (x,y), {{1.1}, {4.2}}, {{3.1}, {2}}, ... | 949 %! A = cellfun (@(x,y) mat2str (x,y), {{1.1}, {4.2}}, {{3.1}, {2}}, ... |
930 %! "UniformOutput", true, "ErrorHandler", @__cellfunerror); | 950 %! "UniformOutput", true, "ErrorHandler", @__cellfunerror); |
931 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]); | 951 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], |
932 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]); | 952 %! [true, true]); |
933 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]); | 953 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], |
934 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]); | 954 %! [true, true]); |
955 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], | |
956 %! [true, true]); | |
957 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], | |
958 %! [false, false]); | |
935 %! assert ([A(1).index, A(2).index], [1, 2]); | 959 %! assert ([A(1).index, A(2).index], [1, 2]); |
936 | 960 |
937 ## Input arguments can be of type cell array of structure arrays | 961 ## Input arguments can be of type cell array of structure arrays |
938 %!test | 962 %!test |
939 %! a = struct ("a", 1, "b", 2); b = struct ("a", 1, "b", 3); | 963 %! a = struct ("a", 1, "b", 2); b = struct ("a", 1, "b", 3); |
982 %!assert (cellfun ("isclass", {zeros([2,2,2]),"test"}, "double"), [true,false]) | 1006 %!assert (cellfun ("isclass", {zeros([2,2,2]),"test"}, "double"), [true,false]) |
983 %!assert (cellfun ("size", {zeros([1,2,3]),1}, 1), [1,1]) | 1007 %!assert (cellfun ("size", {zeros([1,2,3]),1}, 1), [1,1]) |
984 %!assert (cellfun ("size", {zeros([1,2,3]),1}, 2), [2,1]) | 1008 %!assert (cellfun ("size", {zeros([1,2,3]),1}, 2), [2,1]) |
985 %!assert (cellfun ("size", {zeros([1,2,3]),1}, 3), [3,1]) | 1009 %!assert (cellfun ("size", {zeros([1,2,3]),1}, 3), [3,1]) |
986 %!assert (cellfun (@atan2, {1,1}, {1,2}), [atan2(1,1), atan2(1,2)]) | 1010 %!assert (cellfun (@atan2, {1,1}, {1,2}), [atan2(1,1), atan2(1,2)]) |
987 %!assert (cellfun (@atan2, {1,1}, {1,2},"UniformOutput", false), {atan2(1,1), atan2(1,2)}) | 1011 %!assert (cellfun (@atan2, {1,1}, {1,2},"UniformOutput", false), |
1012 %! {atan2(1,1), atan2(1,2)}) | |
988 %!assert (cellfun (@sin, {1,2;3,4}), sin ([1,2;3,4])) | 1013 %!assert (cellfun (@sin, {1,2;3,4}), sin ([1,2;3,4])) |
989 %!assert (cellfun (@atan2, {1,1;1,1}, {1,2;1,2}), atan2 ([1,1;1,1],[1,2;1,2])) | 1014 %!assert (cellfun (@atan2, {1,1;1,1}, {1,2;1,2}), atan2 ([1,1;1,1],[1,2;1,2])) |
990 %!error cellfun (@factorial, {-1,3}) | 1015 %!error cellfun (@factorial, {-1,3}) |
991 %!assert (cellfun (@factorial,{-1,3},"ErrorHandler",@(x,y) NaN), [NaN,6]) | 1016 %!assert (cellfun (@factorial,{-1,3},"ErrorHandler",@(x,y) NaN), [NaN,6]) |
992 %!assert (cellfun (@(x) x(2),{[1],[1,2]},"ErrorHandler",@(x,y) NaN), [NaN,2]) | 1017 %!assert (cellfun (@(x) x(2),{[1],[1,2]},"ErrorHandler",@(x,y) NaN), [NaN,2]) |
995 %! assert (a, {fullfile("a","b"), fullfile("e","f")}); | 1020 %! assert (a, {fullfile("a","b"), fullfile("e","f")}); |
996 %! assert (b, {"c", "g"}); | 1021 %! assert (b, {"c", "g"}); |
997 %! assert (c, {".d", ".h"}); | 1022 %! assert (c, {".d", ".h"}); |
998 | 1023 |
999 %!assert <*40467> (cellfun (@isreal, {1 inf nan []}), [true, true, true, true]) | 1024 %!assert <*40467> (cellfun (@isreal, {1 inf nan []}), [true, true, true, true]) |
1000 %!assert <*40467> (cellfun (@isreal, {1 inf nan []}, "UniformOutput", false), {true, true, true, true}) | 1025 %!assert <*40467> (cellfun (@isreal, {1 inf nan []}, "UniformOutput", false), |
1001 %!assert <*40467> (cellfun (@iscomplex, {1 inf nan []}), [false, false, false, false]) | 1026 %! {true, true, true, true}) |
1002 %!assert <*40467> (cellfun (@iscomplex, {1 inf nan []}, "UniformOutput", false), {false, false, false, false}) | 1027 %!assert <*40467> (cellfun (@iscomplex, {1 inf nan []}), |
1028 %! [false, false, false, false]) | |
1029 %!assert <*40467> (cellfun (@iscomplex, {1 inf nan []}, "UniformOutput", false), | |
1030 %! {false, false, false, false}) | |
1003 | 1031 |
1004 %!error cellfun (1) | 1032 %!error cellfun (1) |
1005 %!error cellfun ("isclass", 1) | 1033 %!error cellfun ("isclass", 1) |
1006 %!error cellfun ("size", 1) | 1034 %!error cellfun ("size", 1) |
1007 %!error cellfun (@sin, {[]}, "BadParam", false) | 1035 %!error cellfun (@sin, {[]}, "BadParam", false) |
1013 %! __errmsg = S.message; | 1041 %! __errmsg = S.message; |
1014 %! retval = NaN; | 1042 %! retval = NaN; |
1015 %!endfunction | 1043 %!endfunction |
1016 %!test <*58411> | 1044 %!test <*58411> |
1017 %! global __errmsg; | 1045 %! global __errmsg; |
1018 %! assert (cellfun (@factorial, {1, 2, -3}, "ErrorHandler", @__errfcn), [1, 2, NaN]); | 1046 %! assert (cellfun (@factorial, {1, 2, -3}, "ErrorHandler", @__errfcn), |
1047 %! [1, 2, NaN]); | |
1019 %! assert (! isempty (__errmsg)); | 1048 %! assert (! isempty (__errmsg)); |
1020 %! clear -global __errmsg; | 1049 %! clear -global __errmsg; |
1021 */ | 1050 */ |
1022 | 1051 |
1023 // Arrayfun was originally a .m file written by Bill Denney and Jaroslav | 1052 // Arrayfun was originally a .m file written by Bill Denney and Jaroslav |
1535 %! assert (isequal (C, {10, 11; [], 12})); | 1564 %! assert (isequal (C, {10, 11; [], 12})); |
1536 %!test | 1565 %!test |
1537 %! A = arrayfun (@(x,y) array2str (x,y), {1.1, 4}, {3.1, 6}, ... | 1566 %! A = arrayfun (@(x,y) array2str (x,y), {1.1, 4}, {3.1, 6}, ... |
1538 %! "ErrorHandler", @__arrayfunerror); | 1567 %! "ErrorHandler", @__arrayfunerror); |
1539 %! B = isfield (A(1), "message") && isfield (A(1), "index"); | 1568 %! B = isfield (A(1), "message") && isfield (A(1), "index"); |
1540 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]); | 1569 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], |
1541 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]); | 1570 %! [true, true]); |
1542 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]); | 1571 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], |
1543 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]); | 1572 %! [true, true]); |
1573 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], | |
1574 %! [true, true]); | |
1575 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], | |
1576 %! [false, false]); | |
1544 %! assert ([A(1).index, A(2).index], [1, 2]); | 1577 %! assert ([A(1).index, A(2).index], [1, 2]); |
1545 %!test # Overwriting setting of "UniformOutput" true | 1578 %!test # Overwriting setting of "UniformOutput" true |
1546 %! A = arrayfun (@(x,y) array2str (x,y), {1.1, 4}, {3.1, 6}, ... | 1579 %! A = arrayfun (@(x,y) array2str (x,y), {1.1, 4}, {3.1, 6}, ... |
1547 %! "UniformOutput", true, "ErrorHandler", @__arrayfunerror); | 1580 %! "UniformOutput", true, "ErrorHandler", @__arrayfunerror); |
1548 %! B = isfield (A(1), "message") && isfield (A(1), "index"); | 1581 %! B = isfield (A(1), "message") && isfield (A(1), "index"); |
1549 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]); | 1582 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], |
1550 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]); | 1583 %! [true, true]); |
1551 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]); | 1584 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], |
1552 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]); | 1585 %! [true, true]); |
1586 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], | |
1587 %! [true, true]); | |
1588 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], | |
1589 %! [false, false]); | |
1553 %! assert ([A(1).index, A(2).index], [1, 2]); | 1590 %! assert ([A(1).index, A(2).index], [1, 2]); |
1554 | 1591 |
1555 ## Input arguments can be of type character or strings | 1592 ## Input arguments can be of type character or strings |
1556 %!test | 1593 %!test |
1557 %! A = arrayfun (@(x,y) x>y, ["ad", "c", "ghi"], ["cc", "d", "fgh"]); | 1594 %! A = arrayfun (@(x,y) x>y, ["ad", "c", "ghi"], ["cc", "d", "fgh"]); |
1563 %! A = arrayfun (@(x,y) x:y, ["a", "d"], ["c", "f"], "UniformOutput", false); | 1600 %! A = arrayfun (@(x,y) x:y, ["a", "d"], ["c", "f"], "UniformOutput", false); |
1564 %! assert (A, {"abc", "def"}); | 1601 %! assert (A, {"abc", "def"}); |
1565 %!test | 1602 %!test |
1566 %! A = arrayfun (@(x,y) cell2str (x,y), ["a", "d"], ["c", "f"], ... | 1603 %! A = arrayfun (@(x,y) cell2str (x,y), ["a", "d"], ["c", "f"], ... |
1567 %! "ErrorHandler", @__arrayfunerror); | 1604 %! "ErrorHandler", @__arrayfunerror); |
1568 %! B = isfield (A(1), "identifier") && isfield (A(1), "message") && isfield (A(1), "index"); | 1605 %! B = isfield (A(1), "identifier") && isfield (A(1), "message") ... |
1606 %! && isfield (A(1), "index"); | |
1569 %! assert (B, true); | 1607 %! assert (B, true); |
1570 | 1608 |
1571 ## Input arguments can be of type structure | 1609 ## Input arguments can be of type structure |
1572 %!test | 1610 %!test |
1573 %! a = struct ("a", 1.1, "b", 4.2); b = struct ("a", 3.1, "b", 2); | 1611 %! a = struct ("a", 1.1, "b", 4.2); b = struct ("a", 3.1, "b", 2); |
1607 %!test | 1645 %!test |
1608 %! A = arrayfun (@(x,y) x{1} < y{1}, {1.1, 4.2}, {3.1, 2}, "UniformOutput", false); | 1646 %! A = arrayfun (@(x,y) x{1} < y{1}, {1.1, 4.2}, {3.1, 2}, "UniformOutput", false); |
1609 %! assert (A, {true, false}); | 1647 %! assert (A, {true, false}); |
1610 %!test | 1648 %!test |
1611 %! A = arrayfun (@(x,y) num2str(x,y), {1.1, 4.2}, {3.1, 2}, "ErrorHandler", @__arrayfunerror); | 1649 %! A = arrayfun (@(x,y) num2str(x,y), {1.1, 4.2}, {3.1, 2}, "ErrorHandler", @__arrayfunerror); |
1612 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]); | 1650 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], |
1613 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]); | 1651 %! [true, true]); |
1614 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]); | 1652 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], |
1615 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]); | 1653 %! [true, true]); |
1654 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], | |
1655 %! [true, true]); | |
1656 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], | |
1657 %! [false, false]); | |
1616 %! assert ([A(1).index, A(2).index], [1, 2]); | 1658 %! assert ([A(1).index, A(2).index], [1, 2]); |
1617 %!test | 1659 %!test |
1618 %! A = arrayfun (@(x,y) num2str (x,y), {1.1, 4.2}, {3.1, 2}, ... | 1660 %! A = arrayfun (@(x,y) num2str (x,y), {1.1, 4.2}, {3.1, 2}, ... |
1619 %! "UniformOutput", true, "ErrorHandler", @__arrayfunerror); | 1661 %! "UniformOutput", true, "ErrorHandler", @__arrayfunerror); |
1620 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], [true, true]); | 1662 %! assert ([(isfield (A(1), "identifier")), (isfield (A(2), "identifier"))], |
1621 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], [true, true]); | 1663 %! [true, true]); |
1622 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], [true, true]); | 1664 %! assert ([(isfield (A(1), "message")), (isfield (A(2), "message"))], |
1623 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], [false, false]); | 1665 %! [true, true]); |
1666 %! assert ([(isfield (A(1), "index")), (isfield (A(2), "index"))], | |
1667 %! [true, true]); | |
1668 %! assert ([(isempty (A(1).message)), (isempty (A(2).message))], | |
1669 %! [false, false]); | |
1624 %! assert ([A(1).index, A(2).index], [1, 2]); | 1670 %! assert ([A(1).index, A(2).index], [1, 2]); |
1625 */ | 1671 */ |
1626 | 1672 |
1627 static void | 1673 static void |
1628 do_num2cell_helper (const dim_vector& dv, | 1674 do_num2cell_helper (const dim_vector& dv, |