bool CSolverDoc::init_with_nums(const std::vector< std::vector<size_t> >& nums)
{
int all = std::for_each(nums.begin(), nums.end(), sum());
if (all <= 0) return false;
int half = all / 2;
if (half * 2 != all) return false;
int s = 0;
int i;
for (i = 0; s < half; ++i)
s += std::for_each(nums[i].begin(), nums[i].end(), sum());
if (s != half) return false;
newField(i, nums.size() - i);
m_cols_blocks.assign(nums.begin(), nums.begin() + i);
m_rows_blocks.assign(nums.begin() + i, nums.end());
for (size_t i = 0; i < m_cols_blocks.size(); ++i)
m_cols_blocks_flags[i].resize(m_cols_blocks[i].size(), false);
for (size_t i = 0; i < m_rows_blocks.size(); ++i)
m_rows_blocks_flags[i].resize(m_rows_blocks[i].size(), false);
m_max_col_blocks = maxBlocks(m_cols_blocks);
m_max_row_blocks = maxBlocks(m_rows_blocks);
return true;
}
tmp<Field<Type> > readParticleField
(
const word& name,
const IOobjectList cloudObjs
)
{
IOobjectList objects(cloudObjs.lookupClass(IOField<Type>::typeName));
const IOobject* obj = objects.lookup(name);
if (obj != NULL)
{
IOField<Type> newField(*obj);
return tmp<Field<Type> >(new Field<Type>(newField.xfer()));
}
FatalErrorIn
(
"template<class Type>"
"void readParticleField"
"("
"const word&, "
"const IOobjectList"
")"
)
<< "error: cloud field name " << name << " not found"
<< abort(FatalError);
return Field<Type>::null();
}
void readFields
(
PtrList<List<Type> >& values,
const List<word>& fieldNames,
const IOobjectList& cloudObjs
)
{
IOobjectList objects(cloudObjs.lookupClass(IOField<Type>::typeName));
forAll(fieldNames, j)
{
const IOobject* obj = objects.lookup(fieldNames[j]);
if (obj != NULL)
{
Info<< " reading field " << fieldNames[j] << endl;
IOField<Type> newField(*obj);
values.set(j, new List<Type>(newField.xfer()));
}
else
{
FatalErrorIn
(
"template<class Type>"
"void readFields"
"("
"PtrList<List<Type> >&, "
"const List<word>&, "
"const IOobjectList&"
")"
)
<< "Unable to read field " << fieldNames[j]
<< abort(FatalError);
}
}
}
void RecordPrototype::AddField(const std::string & fieldName, SharedPtr<const FieldType> fieldType)
{
if (size_ % fieldType->Alignment() != 0)
{
fprintf(
stderr,
"Adding field '%s' with alignment %u to record prototype '%s' at not divisible offset %u\n",
fieldName.c_str(),
fieldType->Alignment(),
name_.c_str(),
size_
);
}
else if (alignment_ < fieldType->Alignment())
{
alignment_ = fieldType->Alignment();
}
std::auto_ptr<Field> newField(new Field(fieldName, fieldType, size_));
fields_.PushBack(newField);
size_ += fieldType->Size();
defaultValue_.resize(size_, '\0');
}
/**
* If any changes have been made to this component,
* they are now applied to the schematic component
*/
void BOM_TABLE_COMPONENT::ApplyFieldChanges()
{
for( auto& unit : Units )
{
auto cmp = unit.GetComp();
if( !cmp )
continue;
// Iterate over each column
SCH_FIELD* field;
for( auto& column : m_columnList->Columns )
{
if( column && HasValueChanged( column ) )
{
wxString value = GetFieldValue( column->Id() );
switch( column->Id() )
{
// Ignore read-only fields
case BOM_COL_ID_REFERENCE:
case BOM_COL_ID_QUANTITY:
continue;
// Special field considerations
case BOM_COL_ID_FOOTPRINT:
field = cmp->GetField( FOOTPRINT );
break;
case BOM_COL_ID_VALUE:
field = cmp->GetField( VALUE );
break;
case BOM_COL_ID_DATASHEET:
field = cmp->GetField( DATASHEET );
break;
default:
// Find the field by name (but ignore default fields)
field = cmp->FindField( column->Title(), false );
break;
}
// New field needs to be added?
if( !field && !value.IsEmpty() )
{
SCH_FIELD newField( wxPoint( 0, 0 ), -1, cmp, column->Title() );
field = cmp->AddField( newField );
}
if( field )
{
field->SetText( value );
}
}
}
}
}
Foam::List<T> Foam::transform
(
const tensor& rotTensor,
const UList<T>& field
)
{
List<T> newField(field.size());
forAll(field, i)
{
newField[i] = transform(rotTensor, field[i]);
}
void FieldManager::runIteration() {
std::vector<std::vector<bool> > newField(field);
for (int i = 0; i < field.size(); i++) {
for (int j = 0; j < field[i].size(); j++) {
int sum = sumOfNeighbours(i,j);
if (field[i][j]) {
newField[i][j] = (sum == 2) || (sum == 3);
} else {
newField[i][j] = (sum == 3);
}
}
}
field = newField;
}
int main()
{
bool field[WIDTH][HEIGHT];
FILE *f;
if((f = fopen("in.txt", "r")) == NULL)
return -1;
for(int h = 0; h < HEIGHT; h++)
{
for(int w = 0; w < WIDTH; w++)
{
char c = getc(f);
field[w][h] = (c == '1' ? true : false);
}
getc(f);
}
int i;
for(i = 0; i < max_iterations; i++)
{
system("cls");
printField(field);
Sleep(DELAY);
if(!newField(field))
break;
cout << endl << endl;
}
setlocale(LC_ALL, "Russian");
if(i == max_iterations)
cout << "ƒостигнуто максимальное количество итераций." << endl;
else
cout << "ѕоле пришло в стационарное состо¤ние." << endl << endl << endl;
getchar();
return 0;
}
void QgsFieldCalculator::accept()
{
// Set up QgsDistanceArea each time we (re-)calculate
QgsDistanceArea myDa;
myDa.setSourceCrs( mVectorLayer->crs().srsid() );
myDa.setEllipsoidalMode( QgisApp::instance()->mapCanvas()->mapSettings().hasCrsTransformEnabled() );
myDa.setEllipsoid( QgsProject::instance()->readEntry( "Measure", "/Ellipsoid", GEO_NONE ) );
QString calcString = builder->expressionText();
QgsExpression exp( calcString );
exp.setGeomCalculator( myDa );
if ( !mVectorLayer || !mVectorLayer->isEditable() )
return;
if ( ! exp.prepare( mVectorLayer->pendingFields() ) )
{
QMessageBox::critical( 0, tr( "Evaluation error" ), exp.evalErrorString() );
return;
}
QApplication::setOverrideCursor( Qt::WaitCursor );
mVectorLayer->beginEditCommand( "Field calculator" );
//update existing field
if ( mUpdateExistingGroupBox->isChecked() || !mNewFieldGroupBox->isEnabled() )
{
QMap<QString, int>::const_iterator fieldIt = mFieldMap.find( mExistingFieldComboBox->currentText() );
if ( fieldIt != mFieldMap.end() )
{
mAttributeId = fieldIt.value();
}
}
else
{
//create new field
QgsField newField( mOutputFieldNameLineEdit->text(),
( QVariant::Type ) mOutputFieldTypeComboBox->itemData( mOutputFieldTypeComboBox->currentIndex(), Qt::UserRole ).toInt(),
mOutputFieldTypeComboBox->itemData( mOutputFieldTypeComboBox->currentIndex(), Qt::UserRole + 1 ).toString(),
mOutputFieldWidthSpinBox->value(),
mOutputFieldPrecisionSpinBox->value() );
if ( !mVectorLayer->addAttribute( newField ) )
{
QMessageBox::critical( 0, tr( "Provider error" ), tr( "Could not add the new field to the provider." ) );
mVectorLayer->destroyEditCommand();
return;
}
//get index of the new field
const QgsFields& fields = mVectorLayer->pendingFields();
for ( int idx = 0; idx < fields.count(); ++idx )
{
if ( fields[idx].name() == mOutputFieldNameLineEdit->text() )
{
mAttributeId = idx;
break;
}
}
if ( ! exp.prepare( mVectorLayer->pendingFields() ) )
{
QMessageBox::critical( 0, tr( "Evaluation error" ), exp.evalErrorString() );
return;
}
}
if ( mAttributeId == -1 )
{
mVectorLayer->destroyEditCommand();
QApplication::restoreOverrideCursor();
return;
}
//go through all the features and change the new attribute
QgsFeature feature;
bool calculationSuccess = true;
QString error;
bool onlySelected = mOnlyUpdateSelectedCheckBox->isChecked();
QgsFeatureIds selectedIds = mVectorLayer->selectedFeaturesIds();
bool useGeometry = exp.needsGeometry();
int rownum = 1;
bool newField = !mUpdateExistingGroupBox->isChecked();
QVariant emptyAttribute;
if ( newField )
emptyAttribute = QVariant( mVectorLayer->pendingFields()[mAttributeId].type() );
QgsFeatureIterator fit = mVectorLayer->getFeatures( QgsFeatureRequest().setFlags( useGeometry ? QgsFeatureRequest::NoFlags : QgsFeatureRequest::NoGeometry ) );
while ( fit.nextFeature( feature ) )
{
if ( onlySelected )
{
if ( !selectedIds.contains( feature.id() ) )
{
continue;
}
}
exp.setCurrentRowNumber( rownum );
QVariant value = exp.evaluate( &feature );
if ( exp.hasEvalError() )
{
calculationSuccess = false;
error = exp.evalErrorString();
break;
}
else
{
mVectorLayer->changeAttributeValue( feature.id(), mAttributeId, value, newField ? emptyAttribute : feature.attributes().value( mAttributeId ) );
}
rownum++;
}
QApplication::restoreOverrideCursor();
if ( !calculationSuccess )
{
QMessageBox::critical( 0, tr( "Error" ), tr( "An error occured while evaluating the calculation string:\n%1" ).arg( error ) );
mVectorLayer->destroyEditCommand();
return;
}
mVectorLayer->endEditCommand();
QDialog::accept();
}
void Foam::calcTypes::scalarMult::writeAddSubtractField
(
const IOobject& baseHeader,
const IOobject& addHeader,
const fvMesh& mesh,
bool& processed
)
{
typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
if
(
baseHeader.headerClassName() == fieldType::typeName
&& baseHeader.headerClassName() == addHeader.headerClassName()
)
{
if (resultName_ == "")
{
if (calcMode_ == ADD)
{
resultName_ = baseHeader.name() + "_add_" + addHeader.name();
}
else
{
resultName_ = baseHeader.name() + "_subtract_"
+ addHeader.name();
}
}
Info<< " Reading " << baseHeader.name() << endl;
fieldType baseField(baseHeader, mesh);
Info<< " Reading " << addHeader.name() << endl;
fieldType addField(addHeader, mesh);
if (baseField.dimensions() == addField.dimensions())
{
Info<< " Calculating " << resultName_ << endl;
fieldType newField
(
IOobject
(
resultName_,
mesh.time().timeName(),
mesh,
IOobject::NO_READ
),
calcMode_ == ADD ? baseField + addField : baseField - addField
);
newField.write();
}
else
{
Info<< " Cannot calculate " << resultName_ << nl
<< " - inconsistent dimensions: "
<< baseField.dimensions() << " - " << addField.dimensions()
<< endl;
}
processed = true;
}
}
void QgsFieldCalculator::accept()
{
// Set up QgsDistanceArea each time we (re-)calculate
QgsDistanceArea myDa;
myDa.setSourceCrs( mVectorLayer->crs().srsid() );
myDa.setEllipsoidalMode( QgisApp::instance()->mapCanvas()->mapRenderer()->hasCrsTransformEnabled() );
myDa.setEllipsoid( QgsProject::instance()->readEntry( "Measure", "/Ellipsoid", GEO_NONE ) );
QString calcString = builder->expressionText();
QgsExpression exp( calcString );
if ( !mVectorLayer || !mVectorLayer->isEditable() )
return;
if ( ! exp.prepare( mVectorLayer->pendingFields() ) )
{
QMessageBox::critical( 0, tr( "Evaluation error" ), exp.evalErrorString() );
return;
}
mVectorLayer->beginEditCommand( "Field calculator" );
//update existing field
if ( mUpdateExistingGroupBox->isChecked() || !mNewFieldGroupBox->isEnabled() )
{
QMap<QString, int>::const_iterator fieldIt = mFieldMap.find( mExistingFieldComboBox->currentText() );
if ( fieldIt != mFieldMap.end() )
{
mAttributeId = fieldIt.value();
}
}
else
{
//create new field
QgsField newField( mOutputFieldNameLineEdit->text(),
( QVariant::Type ) mOutputFieldTypeComboBox->itemData( mOutputFieldTypeComboBox->currentIndex(), Qt::UserRole ).toInt(),
mOutputFieldTypeComboBox->itemData( mOutputFieldTypeComboBox->currentIndex(), Qt::UserRole + 1 ).toString(),
mOutputFieldWidthSpinBox->value(),
mOutputFieldPrecisionSpinBox->value() );
if ( !mVectorLayer->addAttribute( newField ) )
{
QMessageBox::critical( 0, tr( "Provider error" ), tr( "Could not add the new field to the provider." ) );
mVectorLayer->destroyEditCommand();
return;
}
//get index of the new field
const QgsFieldMap fieldList = mVectorLayer->pendingFields();
QgsFieldMap::const_iterator it = fieldList.constBegin();
for ( ; it != fieldList.constEnd(); ++it )
{
if ( it.value().name() == mOutputFieldNameLineEdit->text() )
{
mAttributeId = it.key();
break;
}
}
}
if ( mAttributeId == -1 )
{
mVectorLayer->destroyEditCommand();
return;
}
//go through all the features and change the new attribute
QgsFeature feature;
bool calculationSuccess = true;
QString error;
bool onlySelected = mOnlyUpdateSelectedCheckBox->isChecked();
QgsFeatureIds selectedIds = mVectorLayer->selectedFeaturesIds();
// block layerModified signals (that would trigger table update)
mVectorLayer->blockSignals( true );
bool useGeometry = exp.needsGeometry();
int rownum = 1;
mVectorLayer->select( mVectorLayer->pendingAllAttributesList(), QgsRectangle(), useGeometry, false );
while ( mVectorLayer->nextFeature( feature ) )
{
if ( onlySelected )
{
if ( !selectedIds.contains( feature.id() ) )
{
continue;
}
}
exp.setCurrentRowNumber( rownum );
exp.setGeomCalculator( myDa );
QVariant value = exp.evaluate( &feature );
if ( exp.hasEvalError() )
{
calculationSuccess = false;
error = exp.evalErrorString();
break;
}
else
{
mVectorLayer->changeAttributeValue( feature.id(), mAttributeId, value, false );
}
rownum++;
}
// stop blocking layerModified signals and make sure that one layerModified signal is emitted
mVectorLayer->blockSignals( false );
mVectorLayer->setModified( true, false );
if ( !calculationSuccess )
{
QMessageBox::critical( 0, tr( "Error" ), tr( "An error occured while evaluating the calculation string:\n%1" ).arg( error ) );
mVectorLayer->destroyEditCommand();
return;
}
mVectorLayer->endEditCommand();
QDialog::accept();
}
Arrays::Arrays()
{
sizeX = 15;
sizeY = 15;
newField(15, 15);
}
MainForm::MainForm( QWidget* parent, const char* name, WFlags fl )
: QMainWindow( parent, name, fl )
{
(void)statusBar();
if ( !name )
setName( "MainForm" );
setCentralWidget( new QWidget( this, "qt_central_widget" ) );
MainFormLayout = new QVBoxLayout( centralWidget(), 11, 6, "MainFormLayout");
listView = new QListView( centralWidget(), "listView" );
listView->addColumn( tr( "Type" ) );
listView->addColumn( tr( "Name" ) );
listView->addColumn( tr( "Login" ) );
listView->addColumn( tr( "Password" ) );
listView->addColumn( tr( "Description" ) );
listView->setResizeMode( QListView::AllColumns );
listView->setSorting(-1);
MainFormLayout->addWidget( listView );
// actions
createProfileAction = new QAction( this, "createProfileAction" );
createProfileAction->setIconSet( QPixmap::fromMimeSource("new.png") );
openProfileAction = new QAction(this, "openProfileAction" );
openProfileAction->setIconSet( QPixmap::fromMimeSource("open.png") );
tb_openProfileAction = new QAction(this, "tb_openProfileAction");
tb_openProfileAction->setIconSet( QPixmap::fromMimeSource("tb_open.png") );
closeProfileAction = new QAction( this, "closeProfileAction" );
closeProfileAction->setIconSet( QPixmap::fromMimeSource("close.png") );
tb_closeProfileAction = new QAction( this, "tb_closeProfileAction" );
tb_closeProfileAction->setIconSet( QPixmap::fromMimeSource("tb_close.png") );
deleteProfileAction = new QAction( this, "deleteProfileAction" );
deleteProfileAction->setIconSet( QPixmap::fromMimeSource("delete_all.png") );
changeProfileAction = new QAction( this, "changeProfileAction" );
fileQuitAction = new QAction( this, "fileQuitAction" );
fileSaveAction = new QAction( this, "fileSaveAction" );
fileSaveAction->setIconSet( QPixmap::fromMimeSource("save.png") );
tb_fileSaveAction = new QAction( this, "tb_fileSaveAction" );
tb_fileSaveAction->setIconSet( QPixmap::fromMimeSource("tb_save.png") );
editUndoAction = new QAction( this, "editUndoAction" );
editUndoAction->setIconSet( QPixmap::fromMimeSource("undo.png") );
tb_editUndoAction = new QAction( this, "editUndoAction" );
tb_editUndoAction->setIconSet( QPixmap::fromMimeSource("tb_undo.png") );
editRedoAction = new QAction( this, "editRedoAction" );
editRedoAction->setIconSet( QPixmap::fromMimeSource("redo.png") );
tb_editRedoAction = new QAction( this, "tb_editRedoAction" );
tb_editRedoAction->setIconSet( QPixmap::fromMimeSource("tb_redo.png") );
editNewField = new QAction( this, "editNewField" );
editNewField->setIconSet( QPixmap::fromMimeSource("new.png") );
editEditField = new QAction( this, "editEditField" );
editEditField->setIconSet( QPixmap::fromMimeSource("edit.png") );
tb_editEditField = new QAction( this, "tb_editEditField" );
tb_editEditField->setIconSet( QPixmap::fromMimeSource("tb_edit.png") );
tb_editNewField = new QAction( this, "tb_editNewField" );
tb_editNewField->setIconSet( QPixmap::fromMimeSource("tb_new.png") );
editDeleteField = new QAction( this, "editDeleteField" );
editDeleteField->setIconSet( QPixmap::fromMimeSource("delete.png") );
tb_editDeleteField = new QAction( this, "tb_editDeleteField" );
tb_editDeleteField->setIconSet( QPixmap::fromMimeSource("tb_delete.png") );
editDeleteAll = new QAction( this, "editDeleteAll" );
editDeleteAll->setIconSet( QPixmap::fromMimeSource("delete_all.png") );
helpAboutAction = new QAction( this, "helpAboutAction" );
// toolbars
fileToolbar = new QToolBar( tr("File"), this, DockTop );
tb_openProfileAction->addTo( fileToolbar);
tb_fileSaveAction->addTo( fileToolbar);
tb_closeProfileAction->addTo( fileToolbar );
editToolbar = new QToolBar( tr("Edit"), this, DockTop );
tb_editUndoAction->addTo( editToolbar );
tb_editRedoAction->addTo( editToolbar );
editToolbar->addSeparator();
tb_editNewField->addTo( editToolbar );
tb_editEditField->addTo( editToolbar );
tb_editDeleteField->addTo( editToolbar );
// menubar
MenuBarEditor = new QMenuBar( this, "MenuBarEditor" );
File = new QPopupMenu( this );
createProfileAction->addTo( File );
openProfileAction->addTo( File );
fileSaveAction->addTo( File );
closeProfileAction->addTo( File );
deleteProfileAction->addTo( File );
changeProfileAction->addTo( File );
File->insertSeparator();
fileQuitAction->addTo( File );
MenuBarEditor->insertItem( QString(""), File, 1 );
Edit = new QPopupMenu( this );
editUndoAction->addTo( Edit );
editRedoAction->addTo( Edit );
Edit->insertSeparator();
editNewField->addTo( Edit );
editEditField->addTo( Edit );
editDeleteField->addTo( Edit );
editDeleteAll->addTo(Edit);
MenuBarEditor->insertItem( QString(""), Edit, 2 );
Help = new QPopupMenu( this );
helpAboutAction->addTo( Help );
MenuBarEditor->insertItem( QString(""), Help, 3 );
rmbMenu = new QPopupMenu( this );
editUndoAction->addTo( rmbMenu );
editRedoAction->addTo( rmbMenu );
rmbMenu->insertSeparator();
editNewField->addTo( rmbMenu );
editEditField->addTo( rmbMenu );
editDeleteField->addTo( rmbMenu );
languageChange();
resize( QSize(700, 400).expandedTo(minimumSizeHint()) );
clearWState( WState_Polished );
connect(createProfileAction, SIGNAL( activated() ), this, SLOT( createProfile() ) );
connect(openProfileAction, SIGNAL( activated() ), this, SLOT( openProfile() ) );
connect(tb_openProfileAction, SIGNAL( activated() ), this, SLOT( openProfile() ) );
connect(closeProfileAction, SIGNAL( activated() ), this, SLOT( closeProfile() ) );
connect(tb_closeProfileAction, SIGNAL( activated() ), this, SLOT( closeProfile() ) );
connect(deleteProfileAction, SIGNAL( activated() ), this, SLOT( deleteProfile() ) );
connect(changeProfileAction, SIGNAL( activated() ), this, SLOT( changeProfile() ) );
connect(fileSaveAction, SIGNAL( activated() ), this, SLOT( save() ) );
connect(tb_fileSaveAction, SIGNAL( activated() ), this, SLOT( save() ) );
connect(fileQuitAction, SIGNAL( activated() ), this, SLOT( close() ) );
connect(editUndoAction, SIGNAL( activated() ), this, SLOT( undo() ) );
connect(tb_editUndoAction, SIGNAL( activated() ), this, SLOT( undo() ) );
connect(editRedoAction, SIGNAL( activated() ), this, SLOT( redo() ) );
connect(tb_editRedoAction, SIGNAL( activated() ), this, SLOT( redo() ) );
connect(editNewField, SIGNAL( activated() ), this, SLOT( newField() ) );
connect(tb_editNewField, SIGNAL( activated() ), this, SLOT( newField() ) );
connect(editEditField, SIGNAL(activated() ), this, SLOT( editField() ) );
connect(tb_editEditField, SIGNAL(activated() ), this, SLOT( editField() ) );
connect(editDeleteField, SIGNAL( activated() ), this, SLOT( deleteField() ) );
connect(tb_editDeleteField, SIGNAL( activated() ), this, SLOT( deleteField() ) );
connect(editDeleteAll, SIGNAL( activated() ), this, SLOT( deleteAll() ) );
connect(helpAboutAction, SIGNAL( activated() ), this, SLOT( about() ) );
connect(listView, SIGNAL( doubleClicked(QListViewItem *) ), this, SLOT( edit(QListViewItem *) ) );
connect(listView, SIGNAL( contextMenuRequested( QListViewItem *, const QPoint&, int) ), this, SLOT( slotRMB( QListViewItem*, const QPoint &, int ) ) );
modified = false;
Caption();
if(!ifProfileExists())
createProfile();
else
setEnabledActions(1);
}
void QgsFieldCalculator::accept()
{
if ( mVectorLayer && mVectorLayer->isEditable() )
{
QString calcString = mExpressionTextEdit->toPlainText();
//create QgsExpression
QgsExpression exp( calcString );
if ( exp.hasParserError() )
{
//expression not valid
QMessageBox::critical( 0, tr( "Syntax error" ), tr( QString( "Invalid expression syntax. The error message of the parser is: '" + exp.parserErrorString() + "'" ).toLocal8Bit().data() ) );
return;
}
if ( ! exp.prepare( mVectorLayer->pendingFields() ) )
{
QMessageBox::critical( 0, tr( "Evaluation error" ), exp.evalErrorString() );
return;
}
mVectorLayer->beginEditCommand( "Field calculator" );
//update existing field
if ( mUpdateExistingFieldCheckBox->checkState() == Qt::Checked )
{
QMap<QString, int>::const_iterator fieldIt = mFieldMap.find( mExistingFieldComboBox->currentText() );
if ( fieldIt != mFieldMap.end() )
{
mAttributeId = fieldIt.value();
}
}
//create new field
else
{
//create new field
QgsField newField( mOutputFieldNameLineEdit->text(),
( QVariant::Type ) mOutputFieldTypeComboBox->itemData( mOutputFieldTypeComboBox->currentIndex(), Qt::UserRole ).toInt(),
mOutputFieldTypeComboBox->itemData( mOutputFieldTypeComboBox->currentIndex(), Qt::UserRole + 1 ).toString(),
mOuputFieldWidthSpinBox->value(),
mOutputFieldPrecisionSpinBox->value() );
if ( !mVectorLayer->addAttribute( newField ) )
{
QMessageBox::critical( 0, tr( "Provider error" ), tr( "Could not add the new field to the provider." ) );
mVectorLayer->destroyEditCommand();
return;
}
//get index of the new field
const QgsFieldMap fieldList = mVectorLayer->pendingFields();
QgsFieldMap::const_iterator it = fieldList.constBegin();
for ( ; it != fieldList.constEnd(); ++it )
{
if ( it.value().name() == mOutputFieldNameLineEdit->text() )
{
mAttributeId = it.key();
break;
}
}
}
if ( mAttributeId == -1 )
{
mVectorLayer->destroyEditCommand();
return;
}
//go through all the features and change the new attribute
QgsFeature feature;
bool calculationSuccess = true;
QString error;
bool onlySelected = ( mOnlyUpdateSelectedCheckBox->checkState() == Qt::Checked );
QgsFeatureIds selectedIds = mVectorLayer->selectedFeaturesIds();
// block layerModified signals (that would trigger table update)
mVectorLayer->blockSignals( true );
bool useGeometry = exp.needsGeometry();
int rownum = 1;
mVectorLayer->select( mVectorLayer->pendingAllAttributesList(), QgsRectangle(), useGeometry, false );
while ( mVectorLayer->nextFeature( feature ) )
{
if ( onlySelected )
{
if ( !selectedIds.contains( feature.id() ) )
{
continue;
}
}
exp.setCurrentRowNumber( rownum );
QVariant value = exp.evaluate( &feature );
if ( exp.hasEvalError() )
{
calculationSuccess = false;
error = exp.evalErrorString();
break;
}
else
{
mVectorLayer->changeAttributeValue( feature.id(), mAttributeId, value, false );
}
rownum++;
}
// stop blocking layerModified signals and make sure that one layerModified signal is emitted
mVectorLayer->blockSignals( false );
mVectorLayer->setModified( true, false );
if ( !calculationSuccess )
{
QMessageBox::critical( 0, tr( "Error" ), tr( "An error occured while evaluating the calculation string:\n%1" ).arg( error ) );
mVectorLayer->destroyEditCommand();
return;
}
mVectorLayer->endEditCommand();
}
QDialog::accept();
}
int main(int argc, char **argv)
{
struct timespec start, finish;
start_time
if (argc<8)
{
printf("Usage: %s x y iteration INCREMENT_TIME, INCREMENT threads EPSILON\n", argv[0]);
}
sscanf(argv[1], "%d", &x);
sscanf(argv[2], "%d", &y);
sscanf(argv[3], "%d", &iteration);
sscanf(argv[4], "%d", &INCREMENT_TIME);
sscanf(argv[5], "%lf", &INCREMENT);
sscanf(argv[6], "%d", &threads);
sscanf(argv[7], "%lf", &EPSILON);
omp_set_num_threads(threads);
field = malloc(sizeof(TemperatureField));
tempField = malloc(sizeof(TemperatureField));
field->x = y;
field->y = x;
#ifdef DISPLAY
XWindow_Init(field);
#endif
int iter, inc;
int *X_Size = malloc(sizeof(int)*INCREMENT_TIME);
int *Y_Size = malloc(sizeof(int)*INCREMENT_TIME);
X_Size[INCREMENT_TIME-1] = x;
Y_Size[INCREMENT_TIME-1] = y;
for (inc=INCREMENT_TIME-2; inc>=0; --inc)
{
X_Size[inc] = X_Size[inc+1] / INCREMENT;
Y_Size[inc] = Y_Size[inc+1] / INCREMENT;
}
for (inc=0; inc<INCREMENT_TIME; ++inc)
{
if (!inc)
{
newField(field, X_Size[inc], Y_Size[inc], 0, 0);
newField(tempField, X_Size[inc], Y_Size[inc], 0, 0);
initField(field);
}
else
{
newField(field, X_Size[inc], Y_Size[inc], X_Size[inc-1], Y_Size[inc-1]);
newField(tempField, X_Size[inc], Y_Size[inc], X_Size[inc-1], Y_Size[inc-1]);
}
#ifdef DISPLAY
XResize(field);
#endif
for (iter=0; iter<iteration; iter++)
{
double error = temperature_iterate(field);
if (error<EPSILON)
{
printf("Finished. iteration=%d, error=%lf\n", iter, error);
break;
}
swapField = field;
field = tempField;
tempField = swapField;
#ifdef DISPLAY
end_time
if (time_elapsed_ns > FRAME_INTERVAL*1000000)
{
start_time;
XRedraw(field);
}
// puts("Field:");
// int i, j;
// for (i=0; i<field->x; ++i)
// {
// for (j=0; j<field->y; ++j)
// printf("%lf ", field->t[i][j]);
// puts("");
// }
#endif
}
}
deleteField(field);
deleteField(tempField);
free(X_Size);
free(Y_Size);
printf("Finished in %d iterations.\n", iter_cnt);
end_time;
printf("%lf\n", time_elapsed_s);
return 0;
}
