Method ApplyIntegrationPoints

comp/bilinearform.cpp:1096–1187

   */

  ApplyIntegrationPoints :: 
  ApplyIntegrationPoints (Array<shared_ptr<CoefficientFunction>> acoefs,
                          const Array<ProxyFunction*> & atrialproxies,
                          Matrix<> apoints, Matrix<> anormals,
                          size_t adimx, size_t adimy, size_t anip)
    : coefs(acoefs), trialproxies{atrialproxies}, dimx(adimx), dimy(adimy), nip(anip),
      points(std::move(apoints)), normals(std::move(anormals))
  { 
      // make my own code
    
    Array<int> proxyoffset;
    int starti = 0;
    for (auto proxy : trialproxies)
      {
        proxyoffset.Append (starti);
        starti += proxy->Evaluator()->Dim();
      }
    
    stringstream s;
    s <<
      "#include <cstddef>\n"
      "extern \"C\" void ApplyIPFunction (size_t nip, double * input, size_t dist_input,\n"
      "                      double * output, size_t dist_output,\n"
      "                      size_t dist, double * pnts, double * nvs) {\n";

    int base_output = 0;
    for (auto cf : coefs)
      {
        auto compiledcf = Compile (cf, false);
        Code code = compiledcf->GenerateProgram(0, false);
        
        s << "{\n";
        // cout << code.header << endl;
        
        for (auto step : Range(compiledcf->Steps()))
          if (auto proxycf = dynamic_cast<ProxyFunction*> (compiledcf->Steps()[step]))
            if (auto pos = trialproxies.Pos(proxycf); pos != trialproxies.ILLEGAL_POSITION)
              {
                s << "auto values_" << step << " = [dist_input,input](size_t i, int comp)\n"
                  " { return input[i + (comp+" << proxyoffset[pos] << ")*dist_input]; };\n";
                s << "bool constexpr has_values_" << step << " = true;\n" << endl;
                // Declare dummy com_ variables to avoid compile errors (won't be used since has_values = true)
                for(auto i : Range(proxycf->Dimension()))
                  s << Var("comp", step,i, proxycf->Dimensions()).Declare("double", 0.0);
              }

        s << "[[maybe_unused]] auto points = [dist,pnts](size_t i, int comp)\n"
          " { return pnts[i+comp*dist]; };\n";
        s << "[[maybe_unused]] auto normals = [dist,nvs](size_t i, int comp)\n"
          " { return nvs[i+comp*dist]; };\n";
        
        s << "for (size_t i = 0; i < nip; i++) {\n";
        s << code.body << endl;
        
          // missing: last step nr
        for (int j = 0; j < cf->Dimension(); j++)
          s << "output[i+"<<base_output+j<<"*dist_output] = "
            << Var(compiledcf->Steps().Size()-1, j, cf->Dimensions()).code << ";\n";