//
// Academic License - for use in teaching, academic research, and meeting
// course requirements at degree granting institutions only.  Not for
// government, commercial, or other organizational use.
// File: sparse.cpp
//
// MATLAB Coder version            : 5.3
// C/C++ source code generated on  : 12-May-2022 07:57:40
//

// Include Files
#include "sparse.h"
#include "anonymous_function.h"
#include "introsort.h"
#include "sparse1.h"
#include "tb_obscheck_internal_types.h"
#include "coder_array.h"

// Function Definitions
//
// Arguments    : const ::coder::array<double, 1U> &varargin_1
//                const ::coder::array<double, 1U> &varargin_2
//                const ::coder::array<double, 1U> &varargin_3
//                sparse *y
// Return Type  : void
//
namespace coder {
void b_sparse(const ::coder::array<double, 1U> &varargin_1,
              const ::coder::array<double, 1U> &varargin_2,
              const ::coder::array<double, 1U> &varargin_3, sparse *y)
{
  anonymous_function b_this;
  array<int, 1U> cidxInt;
  array<int, 1U> ridxInt;
  array<int, 1U> sortedIndices;
  int c;
  int i;
  int nc;
  int ns;
  int ridx;
  nc = varargin_2.size(0);
  ns = varargin_1.size(0);
  ridxInt.set_size(varargin_1.size(0));
  for (ridx = 0; ridx < ns; ridx++) {
    ridxInt[ridx] = static_cast<int>(varargin_1[ridx]);
  }
  ns = varargin_2.size(0);
  cidxInt.set_size(varargin_2.size(0));
  for (ridx = 0; ridx < ns; ridx++) {
    cidxInt[ridx] = static_cast<int>(varargin_2[ridx]);
  }
  sortedIndices.set_size(varargin_2.size(0));
  for (ridx = 0; ridx < nc; ridx++) {
    sortedIndices[ridx] = ridx + 1;
  }
  b_this.workspace.a.set_size(cidxInt.size(0));
  ns = cidxInt.size(0);
  for (i = 0; i < ns; i++) {
    b_this.workspace.a[i] = cidxInt[i];
  }
  b_this.workspace.b.set_size(ridxInt.size(0));
  ns = ridxInt.size(0);
  for (i = 0; i < ns; i++) {
    b_this.workspace.b[i] = ridxInt[i];
  }
  internal::introsort(sortedIndices, cidxInt.size(0), &b_this);
  sparse::permuteVector(sortedIndices, cidxInt);
  sparse::permuteVector(sortedIndices, ridxInt);
  ns = varargin_2.size(0);
  if (ns < 1) {
    ns = 1;
  }
  y->d.set_size(ns);
  y->maxnz = ns;
  y->colidx.set_size(1210);
  y->colidx[0] = 1;
  y->rowidx.set_size(ns);
  for (i = 0; i < ns; i++) {
    y->d[i] = 0.0;
    y->rowidx[i] = 0;
  }
  ns = 0;
  for (c = 0; c < 1209; c++) {
    while ((ns + 1 <= nc) && (cidxInt[ns] == c + 1)) {
      y->rowidx[ns] = ridxInt[ns];
      ns++;
    }
    y->colidx[c + 1] = ns + 1;
  }
  for (ridx = 0; ridx < nc; ridx++) {
    y->d[ridx] = varargin_3[sortedIndices[ridx] - 1];
  }
  ns = 1;
  for (c = 0; c < 1209; c++) {
    ridx = y->colidx[c];
    y->colidx[c] = ns;
    int exitg1;
    do {
      exitg1 = 0;
      i = y->colidx[c + 1];
      if (ridx < i) {
        double val;
        val = 0.0;
        nc = y->rowidx[ridx - 1];
        while ((ridx < i) && (y->rowidx[ridx - 1] == nc)) {
          val += y->d[ridx - 1];
          ridx++;
        }
        if (val != 0.0) {
          y->d[ns - 1] = val;
          y->rowidx[ns - 1] = nc;
          ns++;
        }
      } else {
        exitg1 = 1;
      }
    } while (exitg1 == 0);
  }
  y->colidx[1209] = ns;
}

} // namespace coder

//
// File trailer for sparse.cpp
//
// [EOF]
//