octave: scripts/signal/movfun.m annotate

annotate scripts/signal/movfun.m @ 27923:bd51beb6205e

update formatting of copyright notices * Use <https://octave.org/copyright/> instead of <https://octave.org/COPYRIGHT.html/>. * For consistency with other comments in the Octave sources, use C++-style comments for copyright blocks in C and C++ files. * Use delimiters above and below copyright blocks that are appropriate for the language used in the file. * Eliminate extra spacing inside copyright blocks. * lex.ll (looks_like_copyright): Also allow newlines and carriage returns before the word "Copyright". * scripts/mk-doc.pl (gethelp): Also skip empty comment lines. * bp-table.cc, type.m: Adjust tests.

author	John W. Eaton <jwe@octave.org>
date	Wed, 08 Jan 2020 11:59:41 -0500
parents	1891570abac8
children	bdad8ca48700

rev	line source
27923 bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	1 ########################################################################
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	2 ##
27919 1891570abac8 update Octave Project Developers copyright for the new year John W. Eaton <jwe@octave.org> parents: 27918 diff changeset	3 ## Copyright (C) 2018-2020 The Octave Project Developers
27918 b442ec6dda5c use centralized file for copyright info for individual contributors John W. Eaton <jwe@octave.org> parents: 26376 diff changeset	4 ##
27923 bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	5 ## See the file COPYRIGHT.md in the top-level directory of this
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	6 ## distribution or <https://octave.org/copyright/>.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	7 ##
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	8 ## This file is part of Octave.
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	9 ##
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	10 ## Octave is free software: you can redistribute it and/or modify it
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	11 ## under the terms of the GNU General Public License as published by
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	12 ## the Free Software Foundation, either version 3 of the License, or
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	13 ## (at your option) any later version.
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	14 ##
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	15 ## Octave is distributed in the hope that it will be useful, but
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	16 ## WITHOUT ANY WARRANTY; without even the implied warranty of
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	17 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	18 ## GNU General Public License for more details.
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	19 ##
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	20 ## You should have received a copy of the GNU General Public License
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	21 ## along with Octave; see the file COPYING. If not, see
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	22 ## <https://www.gnu.org/licenses/>.
27923 bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	23 ##
bd51beb6205e update formatting of copyright notices John W. Eaton <jwe@octave.org> parents: 27919 diff changeset	24 ########################################################################
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	25
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	26 ## Author: Juan Pablo Carbajal <ajuanpi+dev@gmail.com>
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	27 ## Created: 2018-08-09
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	28
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	29 ## -- texinfo --
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	30 ## @deftypefn {} {@var{y} =} movfun (@var{fcn}, @var{x}, @var{wlen})
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	31 ## @deftypefnx {} {@var{y} =} movfun (@var{fcn}, @var{x}, @var{[@var{nb}, @var{na}}])
26261 eb1903f8bf98 movfun.m: Tweak documentation and remove spaces at EOL. Rik <rik@octave.org> parents: 26260 diff changeset	32 ## @deftypefnx {} {@var{y} =} movfun (@dots{}, "@var{property}", @var{value})
eb1903f8bf98 movfun.m: Tweak documentation and remove spaces at EOL. Rik <rik@octave.org> parents: 26260 diff changeset	33 ##
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	34 ## Apply function @var{fcn} to a moving window of length @var{wlen} on data
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	35 ## @var{x}.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	36 ##
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	37 ## If @var{wlen} is a scalar, the function @var{fcn} is applied to a moving
26249 78c4aadfbfd9 movfun.m, movslice.m: Add support for even-size, asymmetric windows for Matlab compatibility. Rik <rik@octave.org> parents: 26248 diff changeset	38 ## window of length @var{wlen}. When @var{wlen} is an odd number the window is
26260 9d3c22f7fff1 movfun.m: Make Texinfo documentation prettier by marking some items as non-breakable. Rik <rik@octave.org> parents: 26259 diff changeset	39 ## symmetric and includes @w{@code{(@var{wlen} - 1) / 2}} elements on either
9d3c22f7fff1 movfun.m: Make Texinfo documentation prettier by marking some items as non-breakable. Rik <rik@octave.org> parents: 26259 diff changeset	40 ## side of the central element. For example, when calculating the output at
9d3c22f7fff1 movfun.m: Make Texinfo documentation prettier by marking some items as non-breakable. Rik <rik@octave.org> parents: 26259 diff changeset	41 ## index 5 with a window length of 3, @code{movfun} uses data elements
9d3c22f7fff1 movfun.m: Make Texinfo documentation prettier by marking some items as non-breakable. Rik <rik@octave.org> parents: 26259 diff changeset	42 ## @w{@code{[4, 5, 6]}}. If @var{wlen} is an even number, the window is
9d3c22f7fff1 movfun.m: Make Texinfo documentation prettier by marking some items as non-breakable. Rik <rik@octave.org> parents: 26259 diff changeset	43 ## asymmetric and has @w{@code{@var{wlen}/2}} elements to the left of the
26261 eb1903f8bf98 movfun.m: Tweak documentation and remove spaces at EOL. Rik <rik@octave.org> parents: 26260 diff changeset	44 ## central element and @w{@code{@var{wlen}/2 - 1}} elements to the right of the
eb1903f8bf98 movfun.m: Tweak documentation and remove spaces at EOL. Rik <rik@octave.org> parents: 26260 diff changeset	45 ## central element. For example, when calculating the output at index 5 with a
eb1903f8bf98 movfun.m: Tweak documentation and remove spaces at EOL. Rik <rik@octave.org> parents: 26260 diff changeset	46 ## window length of 4, @code{movfun} uses data elements
eb1903f8bf98 movfun.m: Tweak documentation and remove spaces at EOL. Rik <rik@octave.org> parents: 26260 diff changeset	47 ## @w{@code{[3, 4, 5, 6]}}.
26249 78c4aadfbfd9 movfun.m, movslice.m: Add support for even-size, asymmetric windows for Matlab compatibility. Rik <rik@octave.org> parents: 26248 diff changeset	48 ##
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	49 ## If @var{wlen} is an array with two elements @w{@code{[@var{nb}, @var{na}]}},
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	50 ## the function is applied to a moving window @code{-@var{nb}:@var{na}}. This
26261 eb1903f8bf98 movfun.m: Tweak documentation and remove spaces at EOL. Rik <rik@octave.org> parents: 26260 diff changeset	51 ## window includes @var{nb} number of elements @emph{before} the current
eb1903f8bf98 movfun.m: Tweak documentation and remove spaces at EOL. Rik <rik@octave.org> parents: 26260 diff changeset	52 ## element and @var{na} number of elements @emph{after} the current element.
26249 78c4aadfbfd9 movfun.m, movslice.m: Add support for even-size, asymmetric windows for Matlab compatibility. Rik <rik@octave.org> parents: 26248 diff changeset	53 ## The current element is always included. For example, given
26260 9d3c22f7fff1 movfun.m: Make Texinfo documentation prettier by marking some items as non-breakable. Rik <rik@octave.org> parents: 26259 diff changeset	54 ## @w{@code{@var{wlen} = [3, 0]}}, the data used to calculate index 5 is
9d3c22f7fff1 movfun.m: Make Texinfo documentation prettier by marking some items as non-breakable. Rik <rik@octave.org> parents: 26259 diff changeset	55 ## @w{@code{[2, 3, 4, 5]}}.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	56 ##
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	57 ## During calculations the data input @var{x} is reshaped into a 2-dimensional
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	58 ## @var{wlen}-by-@var{N} matrix and @var{fcn} is called on this new matrix.
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	59 ## Therefore, @var{fcn} must accept an array input argument and apply the
26255 36b96226107c movfun.m: Write more complete documentation for "same" option. Rik <rik@octave.org> parents: 26253 diff changeset	60 ## computation along dimension 1, i.e., down the columns of the array.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	61 ##
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	62 ## When applied to an array (possibly multi-dimensional) with @var{n} columns,
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	63 ## @var{fcn} may return a result in either of two formats: @w{Format 1)}
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	64 ## an array of size 1-by-@var{n}-by-@var{dim3}-by-@dots{}-by-@var{dimN}. This
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	65 ## is the typical output format from Octave core functions. Type
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	66 ## @code{demo ("movfun", 5)} for an example of this use case.
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	67 ## @w{Format 2)} a row vector of length
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	68 ## @code{@var{n} * @var{numel_higher_dims}} where @var{numel_higher_dims} is
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	69 ## @w{@code{prod (size (@var{x})(3:end))}}. The output of @var{fcn} for the
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	70 ## i-th input column must be found in the output at indices
26260 9d3c22f7fff1 movfun.m: Make Texinfo documentation prettier by marking some items as non-breakable. Rik <rik@octave.org> parents: 26259 diff changeset	71 ## @w{@code{i:@var{n}:(@var{n}*@var{numel_higher_dims})}}.
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	72 ## This format is useful when concatenating functions into arrays, or when
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	73 ## using @code{nthargout}. Type @code{demo ("movfun", 6)} for an example of
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	74 ## this case.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	75 ##
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	76 ## The calculation can be controlled by specifying @var{property}/@var{value}
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	77 ## pairs. Valid properties are
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	78 ##
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	79 ## @table @asis
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	80 ##
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	81 ## @item @qcode{"dim"}
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	82 ## Operate along the dimension specified, rather than the default of the first
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	83 ## non-singleton dimension.
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	84 ##
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	85 ## @item @qcode{"Endpoints"}
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	86 ##
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	87 ## This property controls how results are calculated at the boundaries
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	88 ## (@w{endpoints}) of the window. Possible values are:
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	89 ##
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	90 ## @table @asis
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	91 ## @item @qcode{"shrink"} (default)
26253 339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	92 ## The window is truncated at the beginning and end of the array to exclude
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	93 ## elements for which there is no source data. For example, with a window of
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	94 ## length 3, @code{@var{y}(1) = @var{fcn} (@var{x}(1:2))}, and
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	95 ## @code{@var{y}(end) = @var{fcn} (@var{x}(end-1:end))}.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	96 ##
26253 339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	97 ## @item @qcode{"discard"}
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	98 ## Any @var{y} values that use a window extending beyond the original
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	99 ## data array are deleted. For example, with a 10-element data vector and a
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	100 ## window of length 3, the output will contain only 8 elements. The first
26260 9d3c22f7fff1 movfun.m: Make Texinfo documentation prettier by marking some items as non-breakable. Rik <rik@octave.org> parents: 26259 diff changeset	101 ## element would require calculating the function over indices
9d3c22f7fff1 movfun.m: Make Texinfo documentation prettier by marking some items as non-breakable. Rik <rik@octave.org> parents: 26259 diff changeset	102 ## @w{@code{[0, 1, 2]}} and is therefore discarded. The last element would
9d3c22f7fff1 movfun.m: Make Texinfo documentation prettier by marking some items as non-breakable. Rik <rik@octave.org> parents: 26259 diff changeset	103 ## require calculating the function over indices @w{@code{[9, 10, 11]}} and is
9d3c22f7fff1 movfun.m: Make Texinfo documentation prettier by marking some items as non-breakable. Rik <rik@octave.org> parents: 26259 diff changeset	104 ## therefore discarded.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	105 ##
26250 481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	106 ## @item @qcode{"fill"}
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	107 ## Any window elements outside the data array are replaced by @code{NaN}. For
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	108 ## example, with a window of length 3,
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	109 ## @code{@var{y}(1) = @var{fcn} ([NaN, @var{x}(1:2)])}, and
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	110 ## @code{@var{y}(end) = @var{fcn} ([@var{x}(end-1:end), NaN])}.
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	111 ## This option usually results in @var{y} having @code{NaN} values at the
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	112 ## boundaries, although it is influenced by how @var{fcn} handles @code{NaN},
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	113 ## and also by the property @qcode{"nancond"}.
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	114 ##
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	115 ## @item @var{user_value}
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	116 ## Any window elements outside the data array are replaced by the specified
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	117 ## value @var{user_value} which must be a numeric scalar. For example, with a
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	118 ## window of length 3,
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	119 ## @code{@var{y}(1) = @var{fcn} ([@var{user_value}, @var{x}(1:2)])}, and
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	120 ## @code{@var{y}(end) = @var{fcn} ([@var{x}(end-1:end), @var{user_value}])}.
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	121 ## A common choice for @var{user_value} is 0.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	122 ##
26255 36b96226107c movfun.m: Write more complete documentation for "same" option. Rik <rik@octave.org> parents: 26253 diff changeset	123 ## @item @qcode{"same"}
36b96226107c movfun.m: Write more complete documentation for "same" option. Rik <rik@octave.org> parents: 26253 diff changeset	124 ## Any window elements outside the data array are replaced by the value of
36b96226107c movfun.m: Write more complete documentation for "same" option. Rik <rik@octave.org> parents: 26253 diff changeset	125 ## @var{x} at the boundary. For example, with a window of length 3,
36b96226107c movfun.m: Write more complete documentation for "same" option. Rik <rik@octave.org> parents: 26253 diff changeset	126 ## @code{@var{y}(1) = @var{fcn} ([@var{x}(1), @var{x}(1:2)])}, and
36b96226107c movfun.m: Write more complete documentation for "same" option. Rik <rik@octave.org> parents: 26253 diff changeset	127 ## @code{@var{y}(end) = @var{fcn} ([@var{x}(end-1:end), @var{x}(end)])}.
36b96226107c movfun.m: Write more complete documentation for "same" option. Rik <rik@octave.org> parents: 26253 diff changeset	128 ##
26253 339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	129 ## @item @qcode{"periodic"}
26255 36b96226107c movfun.m: Write more complete documentation for "same" option. Rik <rik@octave.org> parents: 26253 diff changeset	130 ## The window is wrapped so that any missing data elements are taken from
36b96226107c movfun.m: Write more complete documentation for "same" option. Rik <rik@octave.org> parents: 26253 diff changeset	131 ## the other side of the data. For example, with a window of length 3,
36b96226107c movfun.m: Write more complete documentation for "same" option. Rik <rik@octave.org> parents: 26253 diff changeset	132 ## @code{@var{y}(1) = @var{fcn} ([@var{x}(end), @var{x}(1:2)])}, and
36b96226107c movfun.m: Write more complete documentation for "same" option. Rik <rik@octave.org> parents: 26253 diff changeset	133 ## @code{@var{y}(end) = @var{fcn} ([@var{x}(end-1:end), @var{x}(1)])}.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	134 ##
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	135 ## @end table
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	136 ##
26253 339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	137 ## Note that for some of these choices, the window size at the boundaries is
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	138 ## not the same as for the central part, and @var{fcn} must work in these
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	139 ## cases.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	140 ##
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	141 ## @item @qcode{"nancond"}
26261 eb1903f8bf98 movfun.m: Tweak documentation and remove spaces at EOL. Rik <rik@octave.org> parents: 26260 diff changeset	142 ## Controls whether @code{NaN} and @code{NA} values should be included (value:
26256 d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	143 ## @qcode{"includenan"}), or excluded (value: @qcode{"omitnan"}), from the data
d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	144 ## passed to @var{fcn}. The default is @qcode{"includenan"}. Caution:
d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	145 ## The @qcode{"omitnan"} option is not yet implemented.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	146 ##
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	147 ## @item @qcode{"outdim"}
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	148 ## A row vector that selects which dimensions of the calculation will appear
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	149 ## in the output @var{y}. This is only useful when @var{fcn} returns an
26260 9d3c22f7fff1 movfun.m: Make Texinfo documentation prettier by marking some items as non-breakable. Rik <rik@octave.org> parents: 26259 diff changeset	150 ## N-dimensional array in @w{Format 1}. The default is to return all output
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	151 ## dimensions.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	152 ##
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	153 ## @end table
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	154 ##
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	155 ## Programming Note: The property @qcode{"outdim"} can be used to save memory
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	156 ## when the output of @var{fcn} has many dimensions, or when a wrapper to the
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	157 ## base function that selects the desired outputs is too costly. When memory
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	158 ## is not an issue, the easiest way to select output dimensions is to first
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	159 ## calculate the complete result with @code{movfun} and then filter that result
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	160 ## with indexing. If code complexity is not an issue then a wrapper can be
26248 8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	161 ## created using anonymous functions. For example, if @code{basefcn}
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	162 ## is a function returning a @var{K}-dimensional row output, and only
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	163 ## dimension @var{D} is desired, then the following wrapper could be used.
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	164 ##
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	165 ## @example
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	166 ## @group
26248 8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	167 ## @var{fcn} = @@(x) basefcn (x)(:,size(x,2) * (@var{D}-1) + (1:size(x,2)));
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	168 ## @var{y} = movfun (@@fcn, @dots{});
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	169 ## @end group
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	170 ## @end example
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	171 ##
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	172 ## @seealso{movslice, prepad, postpad, permute, reshape}
58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	173 ## @end deftypefn
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	174
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	175 function y = movfun (fcn, x, wlen, varargin)
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	176
26248 8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	177 if (nargin < 3)
8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	178 print_usage ();
8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	179 endif
8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	180
26258 6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	181 valid_bc = {"shrink", "discard", "fill", "same", "periodic"};
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	182
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	183 ## Parse input arguments
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	184 parser = inputParser ();
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	185 parser.FunctionName = "movfun";
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	186 parser.addParamValue ("Endpoints", "shrink", ...
26258 6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	187 @(x) any (strcmpi (x, valid_bc)) \|\| (isnumeric (x) && isscalar (x)));
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	188 parser.addParamValue ("dim", [], ...
26248 8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	189 @(d) isempty (d) \|\| (isscalar (d) && isindex (d, ndims (x))));
26256 d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	190 parser.addParamValue ("nancond", "includenan", ...
d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	191 @(x) any (strcmpi (x, {"includenan", "omitnan"})));
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	192 parser.addParamValue ("outdim", [], ...
26248 8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	193 @(d) isempty (d) \|\| (isvector (d) && isindex (d)));
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	194
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	195 parser.parse (varargin{:});
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	196 bc = parser.Results.Endpoints; # boundary condition
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	197 dim = parser.Results.dim; # dimension to be used as input
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	198 nancond = parser.Results.nancond; # whether NaN are ignored or not
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	199 outdim = parser.Results.outdim; # selected output dimension of fcn
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	200 clear parser
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	201 ## End parse input arguments
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	202
26256 d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	203 ## If dim was not provided find the first non-singleton dimension.
d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	204 szx = size (x);
d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	205 if (isempty (dim))
d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	206 (dim = find (szx > 1, 1)) \|\| (dim = 1);
d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	207 endif
d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	208
26261 eb1903f8bf98 movfun.m: Tweak documentation and remove spaces at EOL. Rik <rik@octave.org> parents: 26260 diff changeset	209 N = szx(dim);
26258 6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	210
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	211 ## Calculate slicing indices. This call also validates WLEN input.
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	212 [slc, C, Cpre, Cpos, win] = movslice (N, wlen);
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	213
26259 3a8094a70193 movfun.m: Optimize subfunction replaceval_bc() for 33% speed improvement. Rik <rik@octave.org> parents: 26258 diff changeset	214 ## Use [nb, na] format which makes replaceval_bc() simpler.
3a8094a70193 movfun.m: Optimize subfunction replaceval_bc() for 33% speed improvement. Rik <rik@octave.org> parents: 26258 diff changeset	215 if (isscalar (wlen))
3a8094a70193 movfun.m: Optimize subfunction replaceval_bc() for 33% speed improvement. Rik <rik@octave.org> parents: 26258 diff changeset	216 wlen = [wlen, wlen];
3a8094a70193 movfun.m: Optimize subfunction replaceval_bc() for 33% speed improvement. Rik <rik@octave.org> parents: 26258 diff changeset	217 endif
3a8094a70193 movfun.m: Optimize subfunction replaceval_bc() for 33% speed improvement. Rik <rik@octave.org> parents: 26258 diff changeset	218
26256 d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	219 omitnan = strcmpi (nancond, "omitnan");
d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	220 if (omitnan)
d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	221 warning ('movfun: "omitnan" is not yet implemented, using "includenan"');
d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	222 endif
d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	223
26258 6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	224 ## Move the desired dim to be the 1st dimension (rows)
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	225 nd = length (szx); # number of dimensions
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	226 dperm = [dim, 1:(dim-1), (dim+1):nd]; # permutation of dimensions
26258 6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	227 x = permute (x, dperm); # permute dims to first dimension
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	228 ncols = prod (szx(dperm(2:end))); # rest of dimensions as single column
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	229 x = reshape (x, N, ncols); # reshape input
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	230
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	231 ## Obtain function for boundary conditions
26250 481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	232 if (isnumeric (bc))
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	233 bcfunc = @replaceval_bc;
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	234 bcfunc (true, bc); # initialize replaceval function with value
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	235 else
26251 05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	236 switch (tolower (bc))
26253 339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	237 case "shrink"
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	238 bcfunc = @shrink_bc;
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	239
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	240 case "discard"
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	241 bcfunc = [];
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	242 C -= length (Cpre);
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	243 Cpre = Cpos = [];
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	244 N = length (C);
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	245 szx(dperm(1)) = N;
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	246
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	247 case "fill"
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	248 bcfunc = @replaceval_bc;
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	249 bcfunc (true, NaN);
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	250
26258 6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	251 case "same"
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	252 bcfunc = @same_bc;
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	253
26253 339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	254 case "periodic"
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	255 bcfunc = @periodic_bc;
339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	256
26251 05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	257 endswitch
26250 481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	258 endif
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	259
26249 78c4aadfbfd9 movfun.m, movslice.m: Add support for even-size, asymmetric windows for Matlab compatibility. Rik <rik@octave.org> parents: 26248 diff changeset	260 ## FIXME: Validation doesn't seem to work correctly (noted 12/16/2018).
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	261 ## Validate that outdim makes sense
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	262 tmp = fcn (zeros (length (win), 1)); # output for window
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	263 noutdim = length (tmp); # number of output dimensions
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	264 if (! isempty (outdim))
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	265 if (max (outdim) > noutdim)
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	266 error ("Octave:invalid-input-arg", ...
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	267 "movfun: output dimension OUTDIM (%d) is larger than largest available dimension (%d)", ...
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	268 max (outdim), noutdim);
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	269 endif
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	270 else
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	271 outdim = 1:noutdim;
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	272 endif
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	273 soutdim = length (outdim); # length of selected output dimensions
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	274 ## If noutdim is not one then modify function to handle multiple outputs
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	275 if (noutdim > 1)
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	276 fcn_ = @(x) reshape (fcn (x), columns (x), noutdim)(:, outdim);
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	277 else
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	278 fcn_ = fcn;
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	279 endif
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	280
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	281 ## Apply processing to each column
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	282 ## FIXME: Is it faster with cellfun? Don't think so, but needs testing.
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	283 y = zeros (N, ncols, soutdim);
26248 8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	284 parfor i = 1:ncols
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	285 y(:,i,:) = movfun_oncol (fcn_, x(:,i), wlen, bcfunc,
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	286 slc, C, Cpre, Cpos, win, soutdim);
26248 8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	287 endparfor
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	288
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	289 ## Restore shape
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	290 y = reshape (y, [szx(dperm), soutdim]);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	291 y = permute (y, [dperm, nd+1]);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	292 y = squeeze (y);
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	293
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	294 endfunction
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	295
26249 78c4aadfbfd9 movfun.m, movslice.m: Add support for even-size, asymmetric windows for Matlab compatibility. Rik <rik@octave.org> parents: 26248 diff changeset	296 function y = movfun_oncol (fcn, x, wlen, bcfunc, slcidx, C, Cpre, Cpos, win, odim)
26248 8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	297
26253 339db43aa056 movfun.m: Implement "discard" option for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26251 diff changeset	298 N = length (Cpre) + length (C) + length (Cpos);
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	299 y = NA (N, odim);
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	300
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	301 ## Process center part
26249 78c4aadfbfd9 movfun.m, movslice.m: Add support for even-size, asymmetric windows for Matlab compatibility. Rik <rik@octave.org> parents: 26248 diff changeset	302 y(C,:) = fcn (x(slcidx));
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	303
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	304 ## Process boundaries
26249 78c4aadfbfd9 movfun.m, movslice.m: Add support for even-size, asymmetric windows for Matlab compatibility. Rik <rik@octave.org> parents: 26248 diff changeset	305 if (! isempty (Cpre))
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	306 y(Cpre,:) = bcfunc (fcn, x, Cpre, win, wlen, odim);
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	307 endif
26249 78c4aadfbfd9 movfun.m, movslice.m: Add support for even-size, asymmetric windows for Matlab compatibility. Rik <rik@octave.org> parents: 26248 diff changeset	308 if (! isempty (Cpos))
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	309 y(Cpos,:) = bcfunc (fcn, x, Cpos, win, wlen, odim);
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	310 endif
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	311
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	312 endfunction
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	313
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	314 ## Apply "shrink" boundary conditions
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	315 ## Function is not applied to any window elements outside the original data.
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	316 function y = shrink_bc (fcn, x, idxp, win, wlen, odim)
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	317 N = length (x);
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	318 idx = idxp + win;
26258 6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	319 tf = (idx > 0) & (idx <= N); # idx inside boundaries
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	320
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	321 n = length (idxp);
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	322 y = zeros (n, odim);
26260 9d3c22f7fff1 movfun.m: Make Texinfo documentation prettier by marking some items as non-breakable. Rik <rik@octave.org> parents: 26259 diff changeset	323 ## FIXME: This nested for loop accounts for 70% of running time.
9d3c22f7fff1 movfun.m: Make Texinfo documentation prettier by marking some items as non-breakable. Rik <rik@octave.org> parents: 26259 diff changeset	324 ## Given that "shrink" is the default Endpoint value this
26261 eb1903f8bf98 movfun.m: Tweak documentation and remove spaces at EOL. Rik <rik@octave.org> parents: 26260 diff changeset	325 ## code needs to be reworked.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	326 for i = 1:n
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	327 k = idx(tf(:,i),i);
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	328 y(i,:) = fcn (x(k));
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	329 endfor
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	330 endfunction
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	331
26250 481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	332 ## Apply replacement value boundary conditions
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	333 ## Window is padded at beginning and end with user-specified value.
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	334 function y = replaceval_bc (fcn, x, idxp, win, wlen)
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	335
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	336 persistent substitute;
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	337
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	338 ## In-band method to initialize substitute value
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	339 if (islogical (fcn))
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	340 substitute = x;
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	341 return;
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	342 endif
481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	343
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	344 if (min (idxp) == 1)
26259 3a8094a70193 movfun.m: Optimize subfunction replaceval_bc() for 33% speed improvement. Rik <rik@octave.org> parents: 26258 diff changeset	345 ## pre-pad window
3a8094a70193 movfun.m: Optimize subfunction replaceval_bc() for 33% speed improvement. Rik <rik@octave.org> parents: 26258 diff changeset	346 sz = size (x);
3a8094a70193 movfun.m: Optimize subfunction replaceval_bc() for 33% speed improvement. Rik <rik@octave.org> parents: 26258 diff changeset	347 sz(1) = wlen(1);
3a8094a70193 movfun.m: Optimize subfunction replaceval_bc() for 33% speed improvement. Rik <rik@octave.org> parents: 26258 diff changeset	348 x = [substitute(ones (sz)); x];
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	349 idx = idxp + win + wlen(1);
26259 3a8094a70193 movfun.m: Optimize subfunction replaceval_bc() for 33% speed improvement. Rik <rik@octave.org> parents: 26258 diff changeset	350 else
3a8094a70193 movfun.m: Optimize subfunction replaceval_bc() for 33% speed improvement. Rik <rik@octave.org> parents: 26258 diff changeset	351 ## post-pad window
3a8094a70193 movfun.m: Optimize subfunction replaceval_bc() for 33% speed improvement. Rik <rik@octave.org> parents: 26258 diff changeset	352 sz = size (x);
3a8094a70193 movfun.m: Optimize subfunction replaceval_bc() for 33% speed improvement. Rik <rik@octave.org> parents: 26258 diff changeset	353 sz(1) = wlen(2);
3a8094a70193 movfun.m: Optimize subfunction replaceval_bc() for 33% speed improvement. Rik <rik@octave.org> parents: 26258 diff changeset	354 x = [x; substitute(ones (sz))];
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	355 idx = idxp + win;
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	356 endif
26250 481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	357
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	358 y = fcn (x(idx));
26250 481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	359
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	360 endfunction
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	361
26258 6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	362 ## Apply "same" boundary conditions
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	363 ## 'y' values outside window are replaced by value of 'x' at the window
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	364 ## boundary.
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	365 function y = same_bc (fcn, x, idxp, win)
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	366 idx = idxp + win;
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	367 idx(idx < 1) = 1;
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	368 N = length (x);
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	369 idx(idx > N) = N;
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	370 y = fcn (x(idx));
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	371 endfunction
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	372
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	373 ## Apply "periodic" boundary conditions
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	374 ## Window wraps around. Window values outside data array are replaced with
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	375 ## data from the other end of the array.
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	376 function y = periodic_bc (fcn, x, idxp, win)
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	377 N = length (x);
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	378 idx = idxp + win;
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	379 tf = idx < 1;
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	380 idx(tf) = N + idx(tf);
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	381 tf = idx > N;
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	382 idx(tf) = idx(tf) - N;
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	383 y = fcn (x(idx));
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	384 endfunction
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	385
26244 58b3107a00bc Update documentation for movXXX functions (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: 26241 diff changeset	386
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	387 %!demo
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	388 %! clf;
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	389 %! t = 2 * pi * linspace (0,1,100).';
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	390 %! x = sin (3 * t);
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	391 %! xn = x + 0.1 * randn (size (x));
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	392 %! x_s = movfun (@mean, xn, 5, "Endpoints", "shrink");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	393 %! x_p = movfun (@mean, xn, 5, "Endpoints", "periodic");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	394 %! x_m = movfun (@mean, xn, 5, "Endpoints", "same");
26250 481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	395 %! x_z = movfun (@mean, xn, 5, "Endpoints", 0);
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	396 %! x_f = movfun (@mean, xn, 5, "Endpoints", "fill");
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	397 %!
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	398 %! h = plot (t, xn, "o;noisy signal;",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	399 %! t, x, "-;true;",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	400 %! t, x_s, "-;shrink;",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	401 %! t, x_p, "-;periodic;",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	402 %! t, x_m, "-;same;",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	403 %! t, x_z, "-;zero;",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	404 %! t, x_f, "-;fill;");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	405 %! set (h(1), "markerfacecolor", "auto");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	406 %! set (h(2:end), "linewidth", 3);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	407 %! axis tight
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	408 %! xlabel ("time");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	409 %! ylabel ("signal");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	410 %! title ("moving mean with different boundary conditions");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	411 %! #-----------------------------------------------------------------
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	412 %! # Moving mean of noisy sinusoidal function with different boundary
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	413 %! # conditions.
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	414
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	415 %!demo
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	416 %! clf;
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	417 %! t = 2 * pi * linspace (0,1,100).';
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	418 %! x = sin (3 * t);
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	419 %! xn = x + 0.1 * randn (size (x));
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	420 %! nwin = 5;
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	421 %! x_ = zeros (rows (x), nwin);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	422 %! wlen = 3 + (1:nwin) * 4;
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	423 %! for i = 1:nwin
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	424 %! x_(:,i) = movfun (@mean, xn, wlen(i), "Endpoints", "periodic");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	425 %! endfor
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	426 %!
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	427 %! h = plot (t, xn, "o",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	428 %! t, x, "-",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	429 %! t, x_, "-");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	430 %! set (h(1), "markerfacecolor", "auto");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	431 %! set (h(2:end), "linewidth", 3);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	432 %! axis tight
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	433 %! xlabel ("time");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	434 %! ylabel ("signal");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	435 %! title ({'moving mean with "periodic" boundary conditions',
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	436 %! "and windows of different lengths"});
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	437 %! legend (h, {"noisy", "true", strsplit(num2str(wlen)){:}});
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	438 %! #-----------------------------------------------------------------
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	439 %! # Moving mean of noisy sinusoidal function with periodic boundary conditions
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	440 %! # using windows of different lengths.
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	441
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	442 %!demo
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	443 %! clf;
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	444 %! t = linspace (0,1,100).';
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	445 %! x = exp (-(t - [0.1:0.3:1]).^2/2/0.1^2);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	446 %! y = movfun (@max, x, 15);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	447 %!
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	448 %! h = plot (t, x, "-",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	449 %! t, y, "--");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	450 %! axis tight
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	451 %! xlabel ("time");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	452 %! ylabel ("signal");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	453 %! title ("moving max of several Gaussian functions");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	454 %! #-----------------------------------------------------------------
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	455 %! # Moving max of different Gaussian functions.
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	456 %! # Illustrates the application of movfun() to inputs with several columns.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	457
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	458 %!demo
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	459 %! clf;
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	460 %! t = linspace (0,1-1e-2,100).';
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	461 %! w = 2 * pi * 3;
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	462 %! x = sin (w * t);
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	463 %! y = cos (w * t);
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	464 %! y_ = movfun (@diff, x, [1 0], "Endpoints", "periodic");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	465 %! ## Is the same as y_ = x(2:end) - x(1:end-1);
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	466 %! dt = t(2) - t(1);
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	467 %! y_ = y_ / w / dt;
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	468 %!
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	469 %! h = plot (t, x, "-",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	470 %! t, y, "-",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	471 %! t, y_, ":");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	472 %! set (h, "linewidth", 3);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	473 %! axis tight
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	474 %! xlabel ("time");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	475 %! ylabel ("signal");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	476 %! title ("movfun with periodic boundary conditions and asymmetric window");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	477 %! legend (h, {"sin", "cos", "[nb, na]"});
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	478 %! #-----------------------------------------------------------------
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	479 %! # Backward diff() of sinusoidal function with periodic boundary conditions.
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	480 %! # Illustrates the use of asymmetric windows.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	481
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	482 %!demo
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	483 %! clf;
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	484 %! N = 1e3;
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	485 %! wlen = 99;
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	486 %! x = linspace (-1, 1, N).';
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	487 %! pp = [-2 0 1 0];
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	488 %! y = polyval (pp, x);
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	489 %! yn = y + 0.1 * (abs (y) + 0.5) .* exp (randn (N, 1));
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	490 %!
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	491 %! st = movfun (@(y) (statistics (y)).', yn, wlen);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	492 %!
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	493 %! h = plot (x, y, "-",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	494 %! x, yn, ".",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	495 %! x, st(:,[3 6]), "-",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	496 %! x, st(:,6) + [-1 1].*st(:,7), "-",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	497 %! x, st(:,[1 2 4 5]), "-");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	498 %! set (h([1 3:4]), "linewidth", 3); # mean
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	499 %! set (h(5:end), "color", "k");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	500 %! axis tight
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	501 %! xlabel ("x")
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	502 %! ylabel ("y")
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	503 %! title ("movfun() with Format 1 output data");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	504 %! legend (h, {"noiseless", "noisy", "mean", "median"})
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	505 %! #-----------------------------------------------------------------
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	506 %! # Moving window statistics. The plot highlights mean and median.
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	507 %! # Black lines how minimum, first quartile, third quartile, and maximum.
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	508 %! # Demo illustrates the use of functions with multidimensional output.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	509
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	510 %!demo
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	511 %! clf;
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	512 %! N = 1e2;
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	513 %! wlen = 9;
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	514 %! x = linspace (-1, 1, N).';
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	515 %! pp = [-2 0 1 0];
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	516 %! y = polyval (pp, x);
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	517 %! y(:,2) = y + 0.1 * (abs (y) + 0.5) .* exp (randn (N, 1));
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	518 %! y(:,1) = -y(:,1) + 0.1 * randn (N, 1);
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	519 %!
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	520 %! fcn = @(y) [min(y), max(y)];
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	521 %! st = movfun (fcn, y, wlen);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	522 %!
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	523 %! h = plot (x, y, "o",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	524 %! x, squeeze (st(:,1,:)), "-",
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	525 %! x, squeeze (st(:,2,:)), "-");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	526 %! axis tight
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	527 %! set (h(3:4), "color", get (h(1), "color"));
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	528 %! set (h(5:6), "color", get (h(2), "color"));
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	529 %! xlabel ("x")
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	530 %! ylabel ("y")
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	531 %! title ("movfun() with Format 2 output data");
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	532 %! legend (h(1:2), {"data1", "data2"})
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	533 %! #-----------------------------------------------------------------
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	534 %! # Moving min() and max() on the same window.
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	535 %! # Demo illustrates the use of functions with flat multidimensional output.
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	536
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	537 %!test
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	538 %! x = (1:10).' + [-3, 0, 4];
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	539 %! ctrfun = @(x) x(2,:);
26251 05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	540 %! valid_bc = {"periodic", 0, "fill", "same"};
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	541 %! for bc = valid_bc
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	542 %! assert (movfun (ctrfun, x, 3, "Endpoints", bc{1}), x);
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	543 %! endfor
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	544 %! x_ = x; x_([1 end],:) = x([2 end],:);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	545 %! assert (movfun (ctrfun, x, 3, "Endpoints", "shrink"), x_);
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	546
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	547 %!test
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	548 %! ## dim == 2, same as transpose
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	549 %! x = randi (10, 3);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	550 %! ctrfun = @(x) x(2,:);
26251 05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	551 %! valid_bc = {"periodic", 0, "fill", "same"};
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	552 %! for bc = valid_bc
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	553 %! assert (movfun (ctrfun, x.', 3, "Endpoints", bc{1}, "dim", 2), x.');
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	554 %! endfor
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	555 %! x_ = x; x_([1 end],:) = x([2 end],:);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	556 %! assert (movfun (ctrfun, x.', 3, "Endpoints", "shrink", "dim", 2), x_.');
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	557
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	558 %!test
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	559 %! x = randi (10, 3, 10, 2);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	560 %! y = movfun (@(x) x(2,:), x, 3, "Endpoints", "same", "dim", 2);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	561 %! assert (x, y);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	562
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	563 %!test
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	564 %! ## bad zero_bc
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	565 %! x = ones (10, 1);
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	566 %! y = x; y(1:2) = y([end end-1]) = [0.6;0.8];
26250 481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	567 %! assert (movfun (@mean, x, 5, "Endpoints", 0), y);
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	568
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	569 ## Asymmetric windows
26251 05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	570 %!shared x, wlen, wlen02, wlen20, ctrfun, UNO
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	571 %! x = (1:10).' + [-3, 0, 4];
26251 05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	572 %! wlen = [2, 1];
05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	573 %! wlen02 = [0, 2];
05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	574 %! wlen20 = [2, 0];
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	575 %! ctrfun = @(x) x(wlen(1)+1,:);
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	576 %! UNO = ones (7,1);
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	577
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	578 %!assert (movfun (ctrfun, x, wlen, "Endpoints", "periodic"), x)
26250 481708dbc540 movfun.m: Implement <numeric scalar> as value for "Endpoints" property for Matlab compatibility. Rik <rik@octave.org> parents: 26249 diff changeset	579 %!assert (movfun (ctrfun, x, wlen, "Endpoints", 0), x)
26251 05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	580 %!assert (movfun (ctrfun, x, wlen, "Endpoints", "fill"), x)
05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	581 %!assert (movfun (ctrfun, x, wlen, "Endpoints", "same"), x)
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	582 ## for shorter x, indexing fails
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	583 %!error movfun (ctrfun, x, wlen, "Endpoints", "shrink")
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	584
26251 05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	585 %!assert (movfun (@min, UNO, wlen, "Endpoints", "shrink"), UNO)
05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	586 %!assert (movfun (@min, UNO, wlen02, "Endpoints", "shrink"), UNO)
05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	587 %!assert (movfun (@min, UNO, wlen20, "Endpoints", "shrink"), UNO)
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	588
26251 05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	589 %!assert (movfun (@min, UNO, wlen02, "Endpoints", "periodic"), UNO)
05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	590 %!assert (movfun (@min, UNO, wlen20, "Endpoints", "periodic"), UNO)
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	591
26251 05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	592 %!assert (movfun (@max, UNO, wlen02, "Endpoints", 0), UNO)
05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	593 %!assert (movfun (@max, UNO, wlen20, "Endpoints", 0), UNO)
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	594
26251 05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	595 %!assert (movfun (@min, UNO, wlen02, "Endpoints", "fill"), UNO)
05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	596 %!assert (movfun (@min, UNO, wlen20, "Endpoints", "fill"), UNO)
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	597
26251 05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	598 %!assert (movfun (@min, UNO, wlen02, "Endpoints", "same"), UNO)
05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	599 %!assert (movfun (@min, UNO, wlen20, "Endpoints", "same"), UNO)
26241 2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	600
2d80a065ce9a Add functions for calculating value of function handle over windows of data (bug #48774). Juan Pablo Carbajal <ajuanpi+dev@gmail.com> parents: diff changeset	601 ## Multidimensional output
26251 05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	602 %!assert (size( movfun (@(x) [min(x), max(x)], (1:10).', 3)), [10 2])
05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	603 %!assert (size( movfun (@(x) [min(x), max(x)], cumsum (ones (10,5),2), 3)),
05ec27d632da movfun.m: Fix incorrect implementation of "fill" value for "Endpoints" Rik <rik@octave.org> parents: 26250 diff changeset	604 %! [10 5 2])
26246 7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	605 ## outdim > dim
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	606 %!error (movfun (@(x) [min(x), max(x)], (1:10).', 3, "Outdim", 3))
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	607
7adb62e4cc39 movfun.m, movslice.m: Use Octave coding conventions. Rik <rik@octave.org> parents: 26244 diff changeset	608 ## Test input validation
26248 8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	609 %!error movfun ()
8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	610 %!error movfun (@min)
8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	611 %!error movfun (@min, 1)
8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	612 %!error <WLEN must be .* array of integers> movfun (@min, 1, {1})
8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	613 %!error <WLEN must be .* array of integers .= 0> movfun (@min, 1, -1)
8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	614 %!error <WLEN must be .* array of integers> movfun (@min, 1, 1.5)
8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	615 %!error <WLEN must be . 1> movfun (@min, 1, 1)
8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	616 %!error <WLEN must be a scalar or 2-element array> movfun (@min, 1, [1, 2, 3])
26258 6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	617 %!error <WLEN \(3\) must be shorter than length along DIM \(1\)>
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	618 %! movfun (@min, 1, 3)
6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	619 %!error <WLEN \(4\) must be shorter than length along DIM \(1\)>
26248 8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	620 %! movfun (@min, 1, [4, 1]);
26258 6cd1752f21e9 movslice.m, movfun.m: Eliminate duplicate input validation between these functions. Rik <rik@octave.org> parents: 26256 diff changeset	621 %!error <WLEN \(5\) must be shorter than length along DIM \(1\)>
26248 8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	622 %! movfun (@min, 1, [1, 5]);
26256 d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	623 %!warning <"omitnan" is not yet implemented>
d8ebeb1a82ea movfun.m: Change default nancond property value to "includenan" for Matlab compatibility. Rik <rik@octave.org> parents: 26255 diff changeset	624 %! movfun (@min, 1:3, 3, "nancond", "omitnan");
26248 8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	625 ## FIXME: This test is commented out until OUTDIM validation is clarified.
8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	626 %!#error <OUTDIM \(5\) is larger than largest available dimension \(3\)>
8a0778f549e8 movfun.m, movslice.m: Add additional input validation and BIST tests for same. Rik <rik@octave.org> parents: 26246 diff changeset	627 %! movfun (@min, ones (6,3,4), 3, "outdim", 5);