chore: import upstream snapshot with attribution

2026-07-13 12:47:05 +08:00
commit 4f3b7da785
7394 changed files with 2005594 additions and 0 deletions
@@ -0,0 +1,172 @@
+/*
+ *  ******************************************************************************
+ *  *
+ *  *
+ *  * This program and the accompanying materials are made available under the
+ *  * terms of the Apache License, Version 2.0 which is available at
+ *  * https://www.apache.org/licenses/LICENSE-2.0.
+ *  *
+ *  * See the NOTICE file distributed with this work for additional
+ *  * information regarding copyright ownership.
+ *  * Unless required by applicable law or agreed to in writing, software
+ *  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ *  * License for the specific language governing permissions and limitations
+ *  * under the License.
+ *  *
+ *  * SPDX-License-Identifier: Apache-2.0
+ *  *****************************************************************************
+ */
+
+//
+//  @author George A. Shulinok <sgazeos@gmail.com>
+//
+#include <array/NDArrayFactory.h>
+#include <execution/Threads.h>
+#include <helpers/MmulHelper.h>
+#include <ops/declarable/helpers/qr.h>
+#if NOT_EXCLUDED(OP_qr)
+namespace sd {
+namespace ops {
+namespace helpers {
+
+template <typename T>
+NDArray matrixMinor(NDArray& in, sd::LongType col) {
+  NDArray* m = in.ulike();
+  m->setIdentity();
+  auto mRef = *m;
+  auto view = mRef({col, m->rows(), col, m->columns()});
+  auto inView = in({col, m->rows(), col, m->columns()});
+  view->assign(inView);
+  delete view;
+  delete inView;
+  delete m;
+
+  return mRef;
+}
+
+/* m = I - v v^T */
+template <typename T>
+NDArray vmul(NDArray& v, int n) {
+  std::vector<sd::LongType> nShape = {n,n};
+  NDArray res('c', nShape, v.dataType(), v.getContext());  // x = matrix_new(n, n);
+  T const* vBuf = v.getDataBuffer()->primaryAsT<T>();
+  T* resBuf = res.dataBuffer()->primaryAsT<T>();
+  auto interloop = PRAGMA_THREADS_FOR_2D {
+    for (auto i = start_x; i < n; i += inc_x)
+      for (auto j = start_y; j < n; j += inc_y) resBuf[i * n + j] = -2 * vBuf[i] * vBuf[j] + (i == j ? T(1) : T(0));
+  };
+
+  samediff::Threads::parallel_for(interloop, 0, n, 1, 0, n, 1);
+  return res;
+}
+
+template <typename T>
+void qrSingle(NDArray* matrix, NDArray* Q, NDArray* R, bool const fullMatricies) {
+  sd::LongType M = matrix->sizeAt(-2);
+  sd::LongType N = matrix->sizeAt(-1);
+  auto resQ = fullMatricies ? Q->ulike() : new NDArray(NDArrayFactory::create<T>(matrix->ordering(), {M, M}, Q->getContext()));
+  auto resR = fullMatricies ? R->ulike() : matrix->ulike();
+  std::vector<NDArray*> q(M, nullptr);
+
+  std::vector<sd::LongType> mShape = {M};
+  NDArray z = *matrix;
+  NDArray e('c', mShape, DataTypeUtils::fromT<T>(), Q->getContext());  // two internal buffers and scalar for squared norm
+
+  for (sd::LongType k = 0; k < N && k < M - 1; k++) {  // loop for columns, but not further then row number
+    e.nullify();
+    z = matrixMinor<T>(z, k);  // minor computing for current column with given matrix z (initally is a input matrix)
+
+    std::vector<sd::LongType> zeroVec = {0};
+    auto currentColumn = z({0, 0, k, k + 1});  // retrieve k column from z to x buffer
+    auto *normPtr = currentColumn->reduceAlongDimension(reduce::Norm2,&zeroVec);
+    NDArray norm = *normPtr;
+    delete normPtr;
+    
+    if (matrix->t<T>(k, k) > T(0.f)) {  // negate on positive matrix diagonal element
+      NDArray *negNorm = norm * T(-1.f);
+      norm.assign(negNorm);
+      delete negNorm;
+    }
+
+    e.p(k, &norm);
+    NDArray *ePlusColumn = e + (*currentColumn);
+    e.assign(ePlusColumn);
+    delete ePlusColumn;
+    
+    auto *normEPtr = e.reduceAlongDimension(reduce::Norm2, &zeroVec);
+    NDArray *eDivNormE = e / (*normEPtr);
+    e.assign(eDivNormE);
+    delete eDivNormE;
+    delete normEPtr;
+    
+    q[k] = new NDArray(vmul<T>(e, M));
+    auto qQ = z.ulike();
+    MmulHelper::matmul(q[k], &z, qQ, false, false, 0, 0, qQ);
+    z = std::move(*qQ);
+
+    delete currentColumn;
+  }
+
+
+  resQ->assign(q[0]);  //
+
+  for (sd::LongType i = 1; i < N && i < M - 1; i++) {
+    auto tempResQ = resQ;
+    MmulHelper::matmul(q[i], resQ, tempResQ, false, false, 0, 0, tempResQ);  // use mmulMxM?
+    resQ = std::move(tempResQ);
+  }
+  MmulHelper::matmul(resQ, matrix, resR, false, false, 0, 0, resR);
+  // resR *= -1.f;
+  resQ->transposei();
+  if (fullMatricies) {
+    Q->assign(resQ);
+    R->assign(resR);
+  } else {
+    auto resQRef = *resQ;
+    auto resRRef = *resR;
+    auto resQView = resQRef({0, 0, 0, N});
+    auto resRView = resRRef({0, N, 0, 0});
+    Q->assign(resQView);
+    R->assign(resRView);
+    delete resQView;
+    delete resRView;
+  }
+
+  // Clean up allocated NDArrays in q vector
+  for (sd::LongType i = 0; i < M; i++) {
+    if (q[i] != nullptr) {
+      delete q[i];
+    }
+  }
+
+  delete resQ;
+  delete resR;
+}
+
+template <typename T>
+void qr_(NDArray * input, NDArray* outputQ, NDArray* outputR, bool const fullMatricies) {
+  sd::LongType lastDim = input->rankOf() - 1;
+  sd::LongType preLastDim = input->rankOf() - 2;
+  ResultSet listOutQ(outputQ->allTensorsAlongDimension({(int)preLastDim, (int)lastDim}));
+  ResultSet listOutR(outputR->allTensorsAlongDimension({(int)preLastDim, (int)lastDim}));
+  ResultSet listInput(input->allTensorsAlongDimension({(int)preLastDim, (int)lastDim}));
+  auto batching = PRAGMA_THREADS_FOR {
+    for (auto batch = start; batch < stop; batch++) {
+      // qr here
+      qrSingle<T>(listInput.at(batch), listOutQ.at(batch), listOutR.at(batch), fullMatricies);
+    }
+  };
+
+  samediff::Threads::parallel_tad(batching, 0, listOutQ.size(), 1);
+}
+
+void qr(sd::LaunchContext* context, NDArray * input, NDArray* outputQ, NDArray* outputR,
+        bool const fullMatricies) {
+  BUILD_SINGLE_SELECTOR(input->dataType(), qr_, (input, outputQ, outputR, fullMatricies), SD_FLOAT_TYPES);
+}
+
+}  // namespace helpers
+}  // namespace ops
+}  // namespace sd
+#endif