Schneller / effizienter Weg, um trennbare ganzzahlige 2D-Filterkoeffizienten zu zerlegen

Ich möchte schnell feststellen können, ob ein gegebener 2D-Kern mit ganzzahligen Koeffizienten in zwei 1D-Kernel mit ganzzahligen Koeffizienten zerlegbar ist. Z.B

 2   3   2
 4   6   4
 2   3   2

ist trennbar in

 2   3   2

und

 1
 2
 1

Der eigentliche Test der Trennbarkeit scheint mit Integer-Arithmetik recht einfach zu sein, die Zerlegung in 1D-Filter mit Integer-Koeffizienten erweist sich jedoch als schwieriger. Die Schwierigkeit scheint in der Tatsache zu liegen, dass Verhältnisse zwischen Zeilen oder Spalten nicht ganzzahlig sein können (rationale Brüche), z. B. haben wir im obigen Beispiel Verhältnisse von 2, 1/2, 3/2 und 2/3.

Ich möchte nicht wirklich einen Hochleistungsansatz wie SVD verwenden, weil (a) er für meine Bedürfnisse relativ rechenintensiv ist und (b) es immer noch nicht unbedingt hilft, ganzzahlige Koeffizienten zu bestimmen .

Irgendwelche Ideen ?

WEITERE INFORMATIONEN

Koeffizienten können positiv, negativ oder null sein, und es kann pathologische Fälle geben, in denen die Summe eines oder beider 1D-Vektoren null ist, z

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

ist trennbar in

 1  -2   1

und

-1
 0
 1

Ich habe die @PhononAntwort genommen und etwas modifiziert, so dass der GCD-Ansatz nur für die obere Zeile und die linke Spalte und nicht für Zeilen- / Spaltensummen verwendet wird. Dies scheint pathologische Fälle etwas besser zu behandeln. Es kann immer noch fehlschlagen, wenn die obere Zeile oder die linke Spalte Nullen sind. Diese Fälle können jedoch überprüft werden, bevor diese Methode angewendet wird.

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

Vielen Dank @Phononund @Jason Rfür die originellen Ideen dazu.

Ich habs! Das Posten von MATLAB-Code wird heute Abend oder morgen eine Erklärung veröffentlichen

% 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

Vielleicht verharmlost ich das Problem, aber es sieht so aus, als könntest du:

• $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}$

• $\mathbf{x}$

• Danach enthält die normalisierte Liste der Verhältnisse den Wert 1 für die Zeile mit der kleinsten Norm. Sie möchten sehen, ob Sie diese Liste auf irgendeine Weise skalieren können, um eine Liste zu erhalten, die alle ganzzahligen Koeffizienten enthält. Ein Brute-Force-Ansatz könnte einfach eine lineare Suche durchführen, berechnen: Für jeden Wert von , nachdem Sie die skalierte Liste der Verhältnisse berechnet haben, müssen Sie jedes überprüfen, um festzustellen, ob es ganzzahlig ist (ebenfalls mit einer gewissen Toleranz). Setzen Sie gleich dem größten Nenner, nach dem Sie in den Zeilenverhältnissen suchen möchten. x s c a l e d =K x n o r m ,K=1,2,...,MK$\mathbf{x_{norm}}$ $$\mathbf{x_{scaled}} = K\mathbf{x_{norm}}, K = 1, 2, \ldots, M$$ $K$$M$

Nicht die eleganteste Methode, und es gibt wahrscheinlich einen besseren Weg, aber es sollte funktionieren, ist ziemlich einfach zu implementieren und sollte für Matrizen mit bescheidener Größe relativ schnell sein.

$x \otimes y \otimes z$$A$$|A - x \otimes y \otimes z|$
$x\ y\ z$
$y$$z$$x$$x\ y\ z\ x\ y\ z\ ...$ im Gegenzug.

(Aus der ungefähren Faltung als Summe trennbarer Faltungen in math.stackexchange.)