Forma rápida / eficiente de descomponer coeficientes de filtro 2D enteros separables

Me gustaría poder determinar rápidamente si un núcleo 2D dado de coeficientes enteros es separable en dos núcleos 1D con coeficientes enteros. P.ej

 2   3   2
 4   6   4
 2   3   2

es separable en

 2   3   2

y

 1
 2
 1

La prueba real de separabilidad parece ser bastante sencilla utilizando la aritmética de enteros, pero la descomposición en filtros 1D con coeficientes enteros está demostrando ser un problema más difícil. La dificultad parece radicar en el hecho de que las relaciones entre filas o columnas pueden ser no enteras (fracciones racionales), por ejemplo, en el ejemplo anterior tenemos relaciones de 2, 1/2, 3/2 y 2/3.

Realmente no quiero usar un enfoque de servicio pesado como SVD porque (a) es relativamente computacionalmente costoso para mis necesidades y (b) todavía no necesariamente ayuda a determinar los coeficientes enteros .

Algunas ideas ?

MÁS INFORMACIÓN

Los coeficientes pueden ser positivos, negativos o cero, y puede haber casos patológicos en los que la suma de uno o ambos vectores 1D sea cero, p. Ej.

-1   2  -1
 0   0   0
 1  -2   1

es separable en

 1  -2   1

y

-1
 0
 1

Tomé @Phononla respuesta y la modifiqué un poco para que use el enfoque GCD solo en la fila superior y la columna izquierda, en lugar de en las sumas de fila / columna. Esto parece manejar los casos patológicos un poco mejor. Todavía puede fallar si la fila superior o la columna izquierda son todos ceros, pero estos casos se pueden verificar antes de aplicar este método.

function [X, Y, valid] = separate(M)    % separate 2D kernel M into X and Y vectors 
  X = M(1, :);                          % init X = top row of M
  Y = M(:, 1);                          % init Y = left column of M
  nx = numel(X);                        % nx = no of columns in M
  ny = numel(Y);                        % ny = no of rows in M
  gx = X(1);                            % gx = GCD of top row
  for i = 2:nx
    gx = gcd(gx, X(i));
  end
  gy = Y(1);                            % gy = GCD of left column
  for i = 2:ny
    gy = gcd(gy, Y(i));
  end
  X = X / gx;                           % scale X by GCD of X
  Y = Y / gy;                           % scale Y by GCD of Y
  scale = M(1, 1) / (X(1) * Y(1));      % calculate scale factor
  X = X * scale;                        % apply scale factor to X
  valid = all(all((M == Y * X)));       % result valid if we get back our original M
end

Muchas gracias a @Phonony @Jason Rpor las ideas originales para esto.

¡Lo tengo! Al publicar el código MATLAB, publicaremos una explicación esta noche o mañana

% Two original arrays
N = 3;
range = 800;
a = round( range*(rand(N,1)-0.5) )
b = round( range*(rand(1,N)-0.5) )

% Create a matrix;
M = a*b;
N = size(M,1);

% Sanity check
disp([num2str(rank(M)) ' <- this should be 1!']);

% Sum across rows and columns
Sa = M * ones(N,1);
Sb = ones(1,N) * M;

% Get rid of zeros
SSa = Sa( Sa~=0 );
SSb = Sb( Sb~=0 );

if isempty(SSa) | isempty(SSb)
    break;
end

% Sizes of array without zeros
Na = numel(SSa);
Nb = numel(SSb);

% Find Greatest Common Divisor of Sa and Sb.
Ga = SSa(1);
Gb = SSb(1);

for l=2:Na
    Ga = gcd(Ga,SSa(l));
end

for l=2:Nb
    Gb = gcd(Gb,SSb(l));
end

%Divide by the greatest common divisor
Sa = Sa / Ga;
Sb = Sb / Gb;

%Scale one of the vectors
MM = Sa * Sb;
Sa = Sa * (MM(1) / M(1));

disp('Two arrays found:')
Sa
Sb
disp('Sa * Sb = ');
Sa*Sb
disp('Original = ');
M

Tal vez estoy trivializando el problema, pero parece que podrías:

• $N$$M$$\mathbf{A}$$\mathbf{a_i}$$i = 0, 1, \ldots , N-1$

• $j > 0$

  • $\mathbf{a_j}$$\mathbf{a_0}$$j$$\mathbf{r_j}$
  • $\mathbf{r_j}$
  • $\mathbf{r_j}$$\mathbf{a_j}$$\mathbf{a_0}$$j$$0$$\mathbf{x}$
  • $\mathbf{a_j}$$\mathbf{a_0}$

• Si se consideró que todas las filas eran múltiplos constantes de la fila 0 en las pruebas anteriores, entonces tome la lista de escalares de relación de filas $\mathbf{x}$

• $\mathbf{x_{norm}}$ $$\mathbf{x_{scaled}} = K\mathbf{x_{norm}}, K = 1, 2, \ldots, M$$ $K$$M$

No es el método más elegante, y es probable que haya una mejor manera, pero debería funcionar, es bastante simple de implementar y debería ser relativamente rápido para matrices de tamaño modesto.

$x \otimes y \otimes z$$A$$|A - x \otimes y \otimes z|$
$x\ y\ z$
$y$$z$$x$$x\ y\ z\ x\ y\ z\ ...$ en turno.

(De aproximado-a-convolution-as-a-sum-of-separable-convolutions on math.stackexchange).