Merge branch 'master' of https://github.com/fastalgorithms/chunkie

chunkie/@kernel/kernel.m

@@ -58,6 +58,8 @@
         sing           % Singularity type
         splitinfo      % Kernel-split information
         opdims = [0 0] % Dimension of the operator
+        isnan  = false % Boolean, determines if NaN kernel
+        iszero = false % Boolean, determines if zero kernel
 
     end
 
@@ -83,6 +85,8 @@
                       obj = kernel.elast2d(varargin{:});
                   case {'zeros', 'zero', 'z'}
                       obj = kernel.zeros(varargin{:});
+                  case {'nans', 'nan'}
+                      obj = kernel.nans(varargin{:});
                   case {'axis sym helmholtz', 'axissymh', 'axissymhelm'}
                       obj = kernel.axissymhelm2d(varargin{:});
                   case {'axis sym helmholtz difference', 'axissymhdiff' ...
@@ -93,6 +97,15 @@
               end
           elseif ( isa(kern, 'function_handle') )
               obj.eval = kern;
+              try
+                  s = []; s.r = randn(2,1); s.d = randn(2,1); 
+                  s.d2 = randn(2,1); s.n = randn(2,1);
+                  t = []; t.r = randn(2,1); t.d = randn(2,1); 
+                  t.d2 = randn(2,1); t.n = randn(2,1);
+                  obj.opdims = size(kern(s,t));
+              catch
+                  % unable to determine opdims automatically, set empty
+              end
           elseif ( isa(kern, 'kernel') )
               if (numel(kern) == 1)
 		obj = kern;
@@ -125,6 +138,7 @@
         obj = axissymhelm2d(varargin);
         obj = axissymhelm2ddiff(varargin);
         obj = zeros(varargin);
+        obj = nans(varargin);
 
     end
 
@@ -133,6 +147,10 @@
 function K = interleave(kerns)
 %INTERLEAVE   Create a kernel from a matrix of kernels by interleaving.
 
+if any([kerns.isnan])
+    error("kernel.interleave: interleave not supported for nan kernels");
+end
+
 [m, n] = size(kerns);
 
 rowdims = cat(1, kerns(:,1).opdims); rowdims = rowdims(:,1).';
@@ -292,4 +310,13 @@
     K.fmm  = @fmm_;
 end
 
+% 
+if all([kerns.iszero])
+    K = kernel.zeros(opdims(1),opdims(2));
+else
+    K.iszero = false;
+end
+
+
+
 end

chunkie/@kernel/nans.m

@@ -0,0 +1,58 @@
+function obj = nans(m, n)
+%KERNEL.NAN   Construct the nan kernel.
+%   KERNEL.NAN() constructs the nan kernel with operator dimensions
+%   of 1 x 1.
+%
+%   KERNEL.NAN(N) constructs the nan kernel with operator dimensions
+%   of N x N.
+%
+%   KERNEL.NAN(M, N) constructs the NAN kernel with operator dimensions
+%   of M x N.
+
+if ( nargin < 1 )
+    m = 1;
+end
+
+if ( nargin < 2 )
+    n = m;
+end
+
+    function out = eval_(s, t)
+        [~, ns] = size(s.r);
+        [~, nt] = size(t.r);
+        out = nan(m*nt, n*ns);
+    end
+
+    function out = shifted_eval_(s, t, o)
+        [~, ns] = size(s.r);
+        [~, nt] = size(t.r);
+        out = nan(m*nt, n*ns);
+    end
+
+    function varargout = fmm_(eps, s, t, sigma)
+
+        if ( isstruct(t) )
+            [~, nt] = size(t.r);
+        else
+            [~, nt] = size(t);
+        end
+
+        if ( nargout > 0 ), varargout{1} = nan(m*nt, 1); end
+        if ( nargout > 1 ), varargout{2} = nan(2, m*nt); end
+        if ( nargout > 2 ), varargout{3} = nan(3, m*nt); end
+        if ( nargout > 3 )
+            error('CHUNKIE:kernel:nan', 'Too many output arguments for FMM.');
+        end
+
+    end
+
+obj = kernel();
+obj.name   = 'nans';
+obj.opdims = [m n];
+obj.sing   = 'smooth';
+obj.eval   = @eval_;
+obj.shifted_eval   = @shifted_eval_;
+obj.fmm    = @fmm_;
+obj.isnan = true;
+
+end

chunkie/@kernel/plus.m

@@ -0,0 +1,30 @@
+function f = plus(f,g)
+% + Pointwise addition for kernel class
+%
+% Currently only supported for adding two kernel class objects
+% or adding a scalar to a kernel class object.
+
+if (isa(g,'kernel') && isa(f,'kernel'))
+  assert(f.opdims(1) == g.opdims(1) && f.opdims(1) == g.opdims(2), ...
+      'kernel dimensions must agree to add');
+  f.name = ['custom ',f.name,' ',g.name];
+  f.eval = @(varargin) g.eval(varargin{:}) + f.eval(varargin{:});
+  if (isa(g.fmm,'function_handle') && isa(f.fmm,'function_handle'))
+    f.fmm = @(varargin) g.fmm(varargin{:}) + f.fmm(varargin{:});
+  else
+    f.fmm = [];
+  end
+  if or(f.isnan,g.isnan)
+      f = kernel.nans(f.opdims(1),f.opdims(2));
+  end
+  if and(f.iszero,g.iszero)
+      f.iszero = true;
+  else
+      f.iszero = false;
+  end
+else
+    error('KERNEL:plus:invalid', ...
+       'F and G must be either floats or kernel class objects');
+end
+end
+

chunkie/@kernel/times.m

@@ -27,6 +27,13 @@
     else
         f.fmm = [];
     end
+
+    if or(f.isnan,isnan(g))
+        f = kernel.nans(f.opdims(1),f.opdims(2));
+    end
+    if ~f.isnan && (g==0) || f.iszero && ~isnan(g)
+        f = kernel.zeros(f.opdims(1),f.opdims(2));
+    end
 
 else
     error('KERNEL:times:invalid', ...

chunkie/@kernel/zeros.m

@@ -53,5 +53,6 @@
 obj.eval   = @eval_;
 obj.shifted_eval   = @shifted_eval_;
 obj.fmm    = @fmm_;
+obj.iszero = true;
 
 end