C++ columns函数代码示例

XMLRowOutputStream::XMLRowOutputStream(WriteBuffer & ostr_, const Block & sample_)
	: dst_ostr(ostr_)
{
	NamesAndTypesList columns(sample_.getColumnsList());
	fields.assign(columns.begin(), columns.end());
	field_tag_names.resize(sample_.columns());

	bool have_non_numeric_columns = false;
	for (size_t i = 0; i < sample_.columns(); ++i)
	{
		if (!sample_.unsafeGetByPosition(i).type->isNumeric())
			have_non_numeric_columns = true;

		/// В качестве имён элементов будем использовать имя столбца, если оно имеет допустимый вид, или "field", иначе.
		/// Условие, приведённое ниже, более строгое, чем того требует стандарт XML.
		bool is_column_name_suitable = true;
		const char * begin = fields[i].name.data();
		const char * end = begin + fields[i].name.size();
		for (const char * pos = begin; pos != end; ++pos)
		{
			char c = *pos;
			if (!( (c >= 'a' && c <= 'z')
				|| (c >= 'A' && c <= 'Z')
				|| (pos != begin && c >= '0' && c <= '9')
				|| c == '_'
				|| c == '-'
				|| c == '.'))
			{
				is_column_name_suitable = false;
				break;
			}
		}

		field_tag_names[i] = is_column_name_suitable
			? fields[i].name
			: "field";
	}

	if (have_non_numeric_columns)
	{
		validating_ostr.reset(new WriteBufferValidUTF8(dst_ostr));
		ostr = validating_ostr.get();
	}
	else
		ostr = &dst_ostr;
}

QList<QPoint> PrimMaze::neighbors(const QPoint& cell)
{
	QList<QPoint> n;
	if (cell.x() > 0) {
		n.append(cell + QPoint(-1, 0));
	}
	if (cell.y() > 0) {
		n.append(cell + QPoint(0, -1));
	}
	if (cell.y() < rows() - 1) {
		n.append(cell + QPoint(0, 1));
	}
	if (cell.x() < columns() - 1) {
		n.append(cell + QPoint(1, 0));
	}
	return n;
}

rePTerrainRenderable::rePTerrainRenderable()
{
	node = 0;
	columns(256);
	rows(256);
	size(reVec2(2, 2));
	textures[3] = new reTexture();
	textures[3]->fileName("/materials/textures/tiles/arctic/Snow0095_2_S.jpg");
	textures[1] = new reTexture();
	textures[1]->fileName("materials/textures/tiles/arctic/Snow0041_5_S.jpg");
	textures[2] = new reTexture();
	textures[2]->fileName("materials/textures/tiles/arctic/Snow0041_5_S.jpg");
	textures[0] = new reTexture();
	textures[0]->fileName("materials/textures/tiles/arctic/Snow0041_5_S.jpg");
	mesh = new reMesh;
	load();
}

ProgressResult TimerRecordDialog::PreActionDelay(int iActionIndex, TimerRecordCompletedActions eCompletedActions)
{
   wxString sAction = m_pTimerAfterCompleteChoiceCtrl->GetString(iActionIndex);
   wxString sCountdownLabel;
   sCountdownLabel.Printf("%s in:", sAction);

   // Two column layout.
   TimerProgressDialog::MessageTable columns(2);
   auto &column1 = columns[0];
   auto &column2 = columns[1];

   column1.push_back(_("Timer Recording completed."));
   column2.push_back( {} );

   column1.push_back( {} );
   column2.push_back( {} );

   column1.push_back(_("Recording Saved:"));
   column2.push_back(((eCompletedActions & TR_ACTION_SAVED) ? _("Yes") : _("No")));

   column1.push_back(_("Recording Exported:"));
   column2.push_back(((eCompletedActions & TR_ACTION_EXPORTED) ? _("Yes") : _("No")));

   column1.push_back(_("Action after Timer Recording:"));
   column2.push_back(sAction);

   wxDateTime dtNow = wxDateTime::UNow();
   wxTimeSpan tsWait = wxTimeSpan(0, 1, 0, 0);
   wxDateTime dtActionTime = dtNow.Add(tsWait);

   TimerProgressDialog dlgAction(tsWait.GetMilliseconds().GetValue(),
                          _("Audacity Timer Record - Waiting"),
                          columns,
                          pdlgHideStopButton | pdlgHideElapsedTime,
                          sCountdownLabel);

   auto iUpdateResult = ProgressResult::Success;
   bool bIsTime = false;
   while (iUpdateResult == ProgressResult::Success && !bIsTime)
   {
      iUpdateResult = dlgAction.UpdateProgress();
      wxMilliSleep(10);
      bIsTime = (dtActionTime <= wxDateTime::UNow());
   }
   return iUpdateResult;
}

bool Matrix<Type>::equalWithTolerance(const Matrix& otherMatrix, const Type tolerance) const
{
    if (size != otherMatrix.size) {
        return false;
    }

    for (long int i = 0; i < rows(); i++) {
        for (long int j = 0; j < columns(); j++) {
            Type first = access(i, j), second = otherMatrix.access(i, j);
            if (((first - second) > tolerance) || (second - first) > tolerance) {
                return false;
            }
        }
    }

    return true;
}

ColumnPtr FunctionArrayIntersect::castRemoveNullable(const ColumnPtr & column, const DataTypePtr & data_type) const
{
    if (auto column_nullable = checkAndGetColumn<ColumnNullable>(column.get()))
    {
        auto nullable_type = checkAndGetDataType<DataTypeNullable>(data_type.get());
        const auto & nested = column_nullable->getNestedColumnPtr();
        if (nullable_type)
        {
            auto casted_column = castRemoveNullable(nested, nullable_type->getNestedType());
            return ColumnNullable::create(casted_column, column_nullable->getNullMapColumnPtr());
        }
        return castRemoveNullable(nested, data_type);
    }
    else if (auto column_array = checkAndGetColumn<ColumnArray>(column.get()))
    {
        auto array_type = checkAndGetDataType<DataTypeArray>(data_type.get());
        if (!array_type)
            throw Exception{"Cannot cast array column to column with type "
                            + data_type->getName() + " in function " + getName(), ErrorCodes::LOGICAL_ERROR};

        auto casted_column = castRemoveNullable(column_array->getDataPtr(), array_type->getNestedType());
        return ColumnArray::create(casted_column, column_array->getOffsetsPtr());
    }
    else if (auto column_tuple = checkAndGetColumn<ColumnTuple>(column.get()))
    {
        auto tuple_type = checkAndGetDataType<DataTypeTuple>(data_type.get());

        if (!tuple_type)
            throw Exception{"Cannot cast tuple column to type "
                            + data_type->getName() + " in function " + getName(), ErrorCodes::LOGICAL_ERROR};

        auto columns_number = column_tuple->getColumns().size();
        Columns columns(columns_number);

        const auto & types = tuple_type->getElements();

        for (auto i : ext::range(0, columns_number))
        {
            columns[i] = castRemoveNullable(column_tuple->getColumnPtr(i), types[i]);
        }
        return ColumnTuple::create(columns);
    }

    return column;
}

void ListView::resizeColums()
{
    int c = columns();
    if(c == 0)
    {
        return;
    }

    int w1 = viewport()->width();
    int w2 = w1 / c;
    int w3 = w1 - (c - 1) * w2;

    for(int i = 0; i < c - 1; i++)
    {
        setColumnWidth(i, w2);
    }
    setColumnWidth(c - 1, w3);
}

// get the covariance of a contrast given a contrast vector
// if this matrix is X, this function computes c' pinv(X'X) c
double RtDesignMatrix::computeContrastCovariance(
    vnl_vector<double> &contrastVector) {
  if (contrastVector.size() != columns()) {
    cerr << "ERROR: number of elements in contrast vector does not match the "
         << "number of columns in the design matrix" << endl;
    return std::numeric_limits<double>::quiet_NaN();
  }

  // compute the contrast covariance based on the currently known regressors
  // NOTE: this will not be the same as computing it at the end of the
  // experiment when all regressors are known. it would be nice to compute
  // final values using the known design.
  vnl_matrix<double> convec(contrastVector.data_block(),
                            contrastVector.size(), 1);
  vnl_svd<double> pinv(transpose() * (*this));
  vnl_matrix<double> result = convec.transpose() * pinv.pinverse() * convec;
  return result.get(0, 0);
}

    /**
     * Perform an LU decomposition. LAPACK routine DGBTRF is used.
     * The factorization is saved in ludata.
     */
    int BandMatrix::factor() {
        int info=0;
        copy(data.begin(), data.end(), ludata.begin());
        ct_dgbtrf(rows(), columns(), nSubDiagonals(), nSuperDiagonals(), 
            DATA_PTR(ludata), ldim(), DATA_PTR(ipiv()), info);

        // if info = 0, LU decomp succeeded. 
        if (info == 0) {
            m_factored = true;
        }
        else {
	  m_factored = false;
          ofstream fout("bandmatrix.csv");
          fout << *this << endl;
          fout.close();
        }
	return info;
    }

bool QGLPixmapConvolutionFilter::processGL(QPainter *painter, const QPointF &pos, const QPixmap &src, const QRectF &srcRect) const
{
    QGLPixmapConvolutionFilter *filter = const_cast<QGLPixmapConvolutionFilter *>(this);

    m_srcSize = src.size();

    int kernelSize = rows() * columns();
    if (m_prevKernelSize == -1 || m_prevKernelSize != kernelSize) {
        filter->setSource(generateConvolutionShader());
        m_prevKernelSize = kernelSize;
    }

    filter->setOnPainter(painter);
    painter->drawPixmap(pos, src, srcRect);
    filter->removeFromPainter(painter);

    return true;
}

  storage::atable_ptr_t createRawTable() {
    metadata_vec_t columns({ *ColumnMetadata::metadataFromString("INTEGER", "col1"),
                             *ColumnMetadata::metadataFromString("STRING", "col2"),
                             *ColumnMetadata::metadataFromString("FLOAT", "col3") });
    auto main = std::make_shared<RawTable<>>(columns);
    storage::rawtable::RowHelper rh(columns);
    unsigned char *data = nullptr;

    for(size_t i=0; i<10; i++) {
      rh.set<storage::hyrise_int_t>(0, i);
      rh.set<storage::hyrise_string_t>(1, "SomeText" + std::to_string(i));
      rh.set<storage::hyrise_float_t>(2, 1.1*i);
      data = rh.build();
      main->appendRow(data);
      free(data);
    }

    return main;
  }

QString MultiModelPrinter::printGvars()
{
  QString str = printTitle(tr("Global Variables"));
  int gvars = firmware->getCapability(Gvars);
  MultiColumns columns(models.size());
  columns.append("<table border='0' cellspacing='0' cellpadding='1' width='100%'><tr>");
  for (int i=0; i<gvars; i++) {
    columns.append(QString("<td><b>") + tr("GV%1").arg(i+1) + "</b></td>");
  }
  columns.append("</tr><tr>");
  for (int i=0; i<gvars; i++) {
    columns.append("<td>");
    COMPARE(model->flightModeData[0].gvars[i]);
    columns.append("</td>");
  }
  columns.append("</tr>");
  str.append(columns.print());
  return str;
}

TEST_F(VirtualTableTests, test_tableplugin_options) {
  auto table = std::make_shared<optionsTablePlugin>();
  EXPECT_EQ(ColumnOptions::INDEX | ColumnOptions::REQUIRED,
            std::get<2>(table->columns()[0]));

  PluginResponse response;
  PluginRequest request = {{"action", "columns"}};
  EXPECT_TRUE(table->call(request, response).ok());
  auto index_required =
      static_cast<size_t>(ColumnOptions::INDEX | ColumnOptions::REQUIRED);
  EXPECT_EQ(INTEGER(index_required), response[0]["op"]);

  response = table->routeInfo();
  EXPECT_EQ(INTEGER(index_required), response[0]["op"]);

  std::string expected_statement =
      "(`id` INTEGER PRIMARY KEY, `username` TEXT, `name` TEXT) WITHOUT ROWID";
  EXPECT_EQ(expected_statement, columnDefinition(response, true));
}

		sparse<double> sprand(size_t nrow, size_t ncol, double density)
		{
			assert(density <= 1 && density > 0);

			size_t n = (size_t)(density * nrow * ncol);

			dense_vector<size_t> rows(n);
			dense_vector<size_t> columns(n);
			dense_vector<double> values(n);

			for (size_t i = 0; i < n; ++i)
			{
				rows[i] = (size_t)RANDI(0, nrow - 1);
				columns[i] = (size_t)RANDI(0, ncol - 1);
				values[i] = RAND();
			}

			return triplet<double>(rows, columns, values, nrow, ncol, n).to_sparse();
		}

Block ODBCBlockInputStream::readImpl()
{
    if (iterator == result.end())
        return {};

    MutableColumns columns(description.sample_block.columns());
    for (const auto i : ext::range(0, columns.size()))
        columns[i] = description.sample_block.getByPosition(i).column->cloneEmpty();

    size_t num_rows = 0;
    while (iterator != result.end())
    {
        Poco::Data::Row & row = *iterator;

        for (const auto idx : ext::range(0, row.fieldCount()))
        {
            const Poco::Dynamic::Var & value = row[idx];

            if (!value.isEmpty())
            {
                if (description.types[idx].second)
                {
                    ColumnNullable & column_nullable = static_cast<ColumnNullable &>(*columns[idx]);
                    insertValue(column_nullable.getNestedColumn(), description.types[idx].first, value);
                    column_nullable.getNullMapData().emplace_back(0);
                }
                else
                    insertValue(*columns[idx], description.types[idx].first, value);
            }
            else
                insertDefaultValue(*columns[idx], *description.sample_block.getByPosition(idx).column);
        }

        ++iterator;

        ++num_rows;
        if (num_rows == max_block_size)
            break;
    }

    return description.sample_block.cloneWithColumns(std::move(columns));
}