/*! \internal Does one iteration towards a better solution for the problem. See 'solveMaxHelper'. */ bool QSimplex::iterate() { // Find Pivot column int pivotColumn = findPivotColumn(); if (pivotColumn == -1) return false; // Find Pivot row for column int pivotRow = pivotRowForColumn(pivotColumn); if (pivotRow == -1) { qWarning() << "QSimplex: Unbounded problem!"; return false; } // Normalize Pivot Row qreal pivot = valueAt(pivotRow, pivotColumn); if (pivot != 1.0) combineRows(pivotRow, pivotRow, (qreal(1.0) - pivot) / pivot); // Update other rows for (int row=0; row < rows; ++row) { if (row == pivotRow) continue; combineRows(row, pivotRow, -1 * valueAt(row, pivotColumn)); } // Update first column setValueAt(pivotRow, 0, pivotColumn); // dumpMatrix(); // qDebug("------------ end of iteration --------------\n"); return true; }
float HotPlate::valueAt(Point p, int offset_x, int offset_y) { Point np = p; np.x += offset_x; np.y += offset_y; // cover the edges. if(np.x<0 || np.y<0 || np.x >= width || np.y >= height) { if(p.x != np.x && p.y != np.y) { // If we are diagonal, let's try to get the point on the same // axis. if(np.y < 0) { return valueAt(p,offset_x,offset_y+1); } else if(np.y >= height) { return valueAt(p,offset_x,offset_y-1); } else if(np.x < 0) { return valueAt(p,offset_x+1,offset_y); } else if(np.x >= width) { return valueAt(p,offset_x-1,offset_y); } } // Arbitrary factor of 1.5 on edges if(swap) return temp2[p]/1.5; else return temp1[p]/1.5; } // cover the hot positions if(isLocked(np)) return 1; // Use the value listed in the screen pixel if(swap) return temp2[np]; else return temp1[np]; }
status_t AudioPolicyMixCollection::getInputMixForAttr(audio_attributes_t attr, AudioMix **policyMix) { if (strncmp(attr.tags, "addr=", strlen("addr=")) != 0) { return BAD_VALUE; } String8 address(attr.tags + strlen("addr=")); #ifdef LOG_NDEBUG ALOGV("getInputMixForAttr looking for address %s\n mixes available:", address.string()); for (size_t i = 0; i < size(); i++) { sp<AudioPolicyMix> policyMix = valueAt(i); AudioMix *mix = policyMix->getMix(); ALOGV("\tmix %zu address=%s", i, mix->mDeviceAddress.string()); } #endif ssize_t index = indexOfKey(address); if (index < 0) { ALOGW("getInputMixForAttr() no policy for address %s", address.string()); return BAD_VALUE; } sp<AudioPolicyMix> audioPolicyMix = valueAt(index); AudioMix *mix = audioPolicyMix->getMix(); if (mix->mMixType != MIX_TYPE_PLAYERS) { ALOGW("getInputMixForAttr() bad policy mix type for address %s", address.string()); return BAD_VALUE; } *policyMix = mix; return NO_ERROR; }
bool HotPlate::stepHP() { float newValue; float n,s,e,w,here; bool changes = false; float epsilon = 1.0/512.0; for(int x = 0; x < width; x++) { for(int y = 0; y < height; y++) { Point p(x,y); here = valueAt(p,0,0); n = valueAt(p, 0,-1); s = valueAt(p, 0, 1); e = valueAt(p,-1, 0); w = valueAt(p, 1, 0); newValue = (here+n+s+e+w)/5; if(isLocked(p)) newValue = here; if(fabs(newValue - here) > epsilon) changes = true; if(swap) temp2[p] = newValue; else temp1[p] = newValue; } } swap = !swap; return changes; }
void AutomationPattern::processMidiTime( const MidiTime & time ) { if( ! isRecording() ) { if( time >= 0 && hasAutomation() ) { const float val = valueAt( time ); for( objectVector::iterator it = m_objects.begin(); it != m_objects.end(); ++it ) { if( *it ) { ( *it )->setAutomatedValue( val ); } } } } else { if( time >= 0 && ! m_objects.isEmpty() ) { const float value = static_cast<float>( firstObject()->value<float>() ); if( value != m_lastRecordedValue ) { putValue( time, value, true ); m_lastRecordedValue = value; } else if( valueAt( time ) != value ) { removeValue( time, false ); } } } }
void AutomationPattern::flipY( int min, int max ) { timeMap tempMap = m_timeMap; timeMap::ConstIterator iterate = m_timeMap.lowerBound(0); float tempValue = 0; int numPoints = 0; for( int i = 0; ( iterate + i + 1 ) != m_timeMap.end() && ( iterate + i ) != m_timeMap.end() ; i++) { numPoints++; } for( int i = 0; i <= numPoints; i++ ) { if ( min < 0 ) { tempValue = valueAt( ( iterate + i ).key() ) * -1; putValue( MidiTime( (iterate + i).key() ) , tempValue, false); } else { tempValue = max - valueAt( ( iterate + i ).key() ); putValue( MidiTime( (iterate + i).key() ) , tempValue, false); } } generateTangents(); emit dataChanged(); }
/*! \internal */ void QSimplex::reducedRowEchelon() { for (int i = 1; i < rows; ++i) { int factorInObjectiveRow = valueAt(i, 0); combineRows(0, i, -1 * valueAt(0, factorInObjectiveRow)); } }
int SymbolInfoJob::execute() { int ret = 1; int idx = -1; if (end.isNull()) { auto symbol = project()->findSymbol(start, &idx); if (!symbol.isNull()) { write(symbol); ret = 0; } } else { assert(start.fileId() == end.fileId()); auto symbols = project()->openSymbols(start.fileId()); if (symbols && symbols->count()) { bool exact = false; uint32_t idx = symbols->lowerBound(start, &exact); if (exact) { write("(list"); write(symbols->valueAt(idx++)); ret = 0; } else { switch (idx) { case 0: break; case std::numeric_limits<uint32_t>::max(): idx = symbols->count() - 1; break; default: --idx; break; } } const uint32_t count = symbols->count(); while (idx < count) { const Location loc = symbols->keyAt(idx); if (loc > end) break; if (loc >= start) { if (ret) write("(list"); write(symbols->valueAt(idx)); ret = 0; } ++idx; } if (!ret) write(")"); } } return ret; }
/*! \internal */ int QSimplex::findPivotColumn() { qreal min = 0; int minIndex = -1; for (int j = 0; j < columns-1; ++j) { if (valueAt(0, j) < min) { min = valueAt(0, j); minIndex = j; } } return minIndex; }
void odeFunc( double time, double * u, double * du, void * udata ) { int i,j; TCpropensity(time, u, rates, udata); for (i=0; i < TCvars; ++i) { du[i] = 0; for (j=0; j < TCreactions; ++j) { if (valueAt(TCstoic,TCreactions,i,j) != 0) du[i] += rates[j]*valueAt(TCstoic,TCreactions,i,j); } } }
double Mesh::valueAt(const Output* output, double xCoord, double yCoord) const { if (!output) return -9999.0; // We want to find the value at the given coordinate // Loop through all the elements in the dataset and make a list of those std::vector<uint> candidateElementIds; for (int i = 0; i < mElems.count(); i++) { const BBox& bbox = projectedBBox(i); if (bbox.isPointInside(xCoord, yCoord)) candidateElementIds.push_back(i); } if( candidateElementIds.size() == 0 ) return -9999.0; double value; for (uint i=0; i < candidateElementIds.size(); i++) { uint elemIndex = candidateElementIds.at(i); if (!output->isActive(elemIndex)) continue; if (valueAt(elemIndex, xCoord, yCoord, &value, output)) // We successfully got a value, return it and leave return value; } return -9999.0; }
float AutomationPattern::valueAt( const MidiTime & _time ) const { if( m_timeMap.isEmpty() ) { return 0; } if( m_timeMap.contains( _time ) ) { return m_timeMap[_time]; } // lowerBound returns next value with greater key, therefore we take // the previous element to get the current value timeMap::ConstIterator v = m_timeMap.lowerBound( _time ); if( v == m_timeMap.begin() ) { return 0; } if( v == m_timeMap.end() ) { return (v-1).value(); } return valueAt( v-1, _time - (v-1).key() ); }
audio_devices_t AudioPolicyMixCollection::getDeviceAndMixForInputSource(audio_source_t inputSource, audio_devices_t availDevices, AudioMix **policyMix) { for (size_t i = 0; i < size(); i++) { AudioMix *mix = valueAt(i)->getMix(); if (mix->mMixType != MIX_TYPE_RECORDERS) { continue; } for (size_t j = 0; j < mix->mCriteria.size(); j++) { if ((RULE_MATCH_ATTRIBUTE_CAPTURE_PRESET == mix->mCriteria[j].mRule && mix->mCriteria[j].mValue.mSource == inputSource) || (RULE_EXCLUDE_ATTRIBUTE_CAPTURE_PRESET == mix->mCriteria[j].mRule && mix->mCriteria[j].mValue.mSource != inputSource)) { if (availDevices & AUDIO_DEVICE_IN_REMOTE_SUBMIX) { if (policyMix != NULL) { *policyMix = mix; } return AUDIO_DEVICE_IN_REMOTE_SUBMIX; } break; } } } return AUDIO_DEVICE_NONE; }
const MemoryTablePrivate::value_type MemoryTablePrivate::valueAtIndex(size_t index, const TableMetadata *table) { if (index >= table->count) return key_type(); return valueAt(table->index[index].offset, table); }
int add_stack(int depth) { int i, j; int old = swapSize; for(j = 0;j < MATRIX_SIZE;++j) for(i = 0;i < MATRIX_SIZE;++i) arr[i][j] = valueAt(i, j); swapSize = getSwapSize(); assertTrue(swapSize >= old); if (depth > 1) if(add_stack(depth - 1) == -1) fail(); for(j = 0;j < MATRIX_SIZE;++j) for(i = 0;i < MATRIX_SIZE;++i) if(!arr[i][j] == valueAt(i, j)) { printf("incorrect value!\n"); fail(); } }
void AudioPolicyMixCollection::closeOutput(sp<SwAudioOutputDescriptor> &desc) { for (size_t i = 0; i < size(); i++) { sp<AudioPolicyMix> policyMix = valueAt(i); if (policyMix->getOutput() == desc) { policyMix->clearOutput(); } } }
const MemoryTablePrivate::value_type MemoryTablePrivate::value(const key_type &key, const TableMetadata *table) { const IndexElement *tableEnd = end(table); const IndexElement *position = std::lower_bound(begin(table), tableEnd, key); if (position == tableEnd || position->key != key) return value_type(); return valueAt(position->offset, table); }
string addBinary(string a, string b) { int m = a.size(), n = b.size(); if (m == 0) { return b; } if (n == 0) { return a; } int carry = 0; string c = ""; for (int i = 0; i < max(m, n); ++i) { int cur = valueAt(a, m-i-1) + valueAt(b, n-i-1) + carry; carry = cur / 2; if (cur % 2 == 0) { c.append("0"); } else { c.append("1"); } } if (carry) { c.append("1"); } return string(c.rbegin(), c.rend()); }
/*! \internal Reads results from the simplified matrix and saves them in the "result" member of each QSimplexVariable. */ void QSimplex::collectResults() { // All variables are zero unless overridden below. // ### Is this really needed? Is there any chance that an // important variable remains as non-basic at the end of simplex? for (int i = 0; i < variables.size(); ++i) variables[i]->result = 0; // Basic variables // Update the variable indicated in the first column with the value // in the last column. for (int i = 1; i < rows; ++i) { int index = valueAt(i, 0) - 1; if (index < variables.size()) variables[index]->result = valueAt(i, columns - 1); } }
audio_io_handle_t SwAudioOutputCollection::getA2dpOutput() const { for (size_t i = 0; i < size(); i++) { sp<SwAudioOutputDescriptor> outputDesc = valueAt(i); if (!outputDesc->isDuplicated() && outputDesc->device() & AUDIO_DEVICE_OUT_ALL_A2DP) { return this->keyAt(i); } } return 0; }
sp<SwAudioOutputDescriptor> SwAudioOutputCollection::getPrimaryOutput() const { for (size_t i = 0; i < size(); i++) { const sp<SwAudioOutputDescriptor> outputDesc = valueAt(i); if (outputDesc->mFlags & AUDIO_OUTPUT_FLAG_PRIMARY) { return outputDesc; } } return NULL; }
bool QueryJob::locationToString(Location location, const std::function<void(LocationPiece, const String &)> &cb, Flags<WriteFlag> writeFlags) { if (location.isNull()) return false; Flags<Location::ToStringFlag> kf = locationToStringFlags(); kf &= ~Location::ShowContext; cb(Piece_Location, location.toString(kf, &mContextCache)); if (!(writeFlags & NoContext) && !(queryFlags() & QueryMessage::NoContext)) cb(Piece_Context, location.context(kf, &mContextCache)); const bool containingFunction = queryFlags() & QueryMessage::ContainingFunction; const bool containingFunctionLocation = queryFlags() & QueryMessage::ContainingFunctionLocation; const bool cursorKind = queryFlags() & QueryMessage::CursorKind; const bool displayName = queryFlags() & QueryMessage::DisplayName; if (containingFunction || containingFunctionLocation || cursorKind || displayName || !mKindFilters.isEmpty()) { int idx; Symbol symbol = project()->findSymbol(location, &idx); if (symbol.isNull()) { error() << "Somehow can't find" << location << "in symbols"; } else { if (!mKindFilters.filter(symbol)) return false; if (displayName) cb(Piece_SymbolName, symbol.displayName()); if (cursorKind) cb(Piece_Kind, symbol.kindSpelling()); if (containingFunction || containingFunctionLocation) { const uint32_t fileId = location.fileId(); const unsigned int line = location.line(); const unsigned int column = location.column(); auto fileMap = project()->openSymbols(location.fileId()); if (fileMap) { while (idx > 0) { symbol = fileMap->valueAt(--idx); if (symbol.location.fileId() != fileId) break; if (symbol.isDefinition() && RTags::isContainer(symbol.kind) && comparePosition(line, column, symbol.startLine, symbol.startColumn) >= 0 && comparePosition(line, column, symbol.endLine, symbol.endColumn) <= 0) { if (containingFunction) cb(Piece_ContainingFunctionName, symbol.symbolName); if (containingFunctionLocation) cb(Piece_ContainingFunctionLocation, symbol.location.toString(locationToStringFlags() & ~Location::ShowContext)); break; } } } } } } return true; }
sp<SwAudioOutputDescriptor> SwAudioOutputCollection::getOutputFromId(audio_port_handle_t id) const { sp<SwAudioOutputDescriptor> outputDesc = NULL; for (size_t i = 0; i < size(); i++) { outputDesc = valueAt(i); if (outputDesc->getId() == id) { break; } } return outputDesc; }
status_t AudioPolicyMixCollection::getAudioPolicyMix(const String8& address, sp<AudioPolicyMix> &policyMix) const { ssize_t index = indexOfKey(address); if (index < 0) { ALOGE("unregisterPolicyMixes(): mix for address %s not registered", address.string()); return BAD_VALUE; } policyMix = valueAt(index); return NO_ERROR; }
void AutomationPattern::recordValue(MidiTime time, float value) { if( value != m_lastRecordedValue ) { putValue( time, value, true ); m_lastRecordedValue = value; } else if( valueAt( time ) != value ) { removeValue( time ); } }
/*! \internal For a given pivot column, find the pivot row. That is, the row with the minimum associated "quotient" where: - quotient is the division of the value in the last column by the value in the pivot column. - rows with value less or equal to zero are ignored - if two rows have the same quotient, lines are chosen based on the highest variable index (value in the first column) The last condition avoids a bug where artificial variables would be left behind for the second-phase simplex, and with 'good' constraints would be removed before it, what would lead to incorrect results. */ int QSimplex::pivotRowForColumn(int column) { qreal min = qreal(999999999999.0); // ### int minIndex = -1; for (int i = 1; i < rows; ++i) { qreal divisor = valueAt(i, column); if (divisor <= 0) continue; qreal quotient = valueAt(i, columns - 1) / divisor; if (quotient < min) { min = quotient; minIndex = i; } else if ((quotient == min) && (valueAt(i, 0) > valueAt(minIndex, 0))) { minIndex = i; } } return minIndex; }
MemoryTablePrivate::Error MemoryTablePrivate::migrateTo(TableMetadata *other, const TableMetadata *table) { // Copy all live elements to the other table const IndexElement *tableEnd(end(table)); for (const IndexElement *it = begin(table); it != tableEnd; ++it) { MemoryTable::Error error = insert((*it).key, valueAt((*it).offset, table), other); if (error != MemoryTable::NoError) return error; } return MemoryTable::NoError; }
Real FdmHestonSolver::thetaAt(Real s, Real v) const { QL_REQUIRE(condition_->stoppingTimes().front() > 0.0, "stopping time at zero-> can't calculate theta"); calculate(); Matrix thetaValues(resultValues_.rows(), resultValues_.columns()); const Array& rhs = thetaCondition_->getValues(); std::copy(rhs.begin(), rhs.end(), thetaValues.begin()); return (BicubicSpline(x_.begin(), x_.end(), v_.begin(), v_.end(), thetaValues)(std::log(s), v) - valueAt(s, v)) / thetaCondition_->getTime(); }
void testInlineAutomation() { auto song = Engine::getSong(); InstrumentTrack* instrumentTrack = dynamic_cast<InstrumentTrack*>(Track::create(Track::InstrumentTrack, song)); Pattern* notePattern = dynamic_cast<Pattern*>(instrumentTrack->createTCO(0)); notePattern->changeLength(MidiTime(4, 0)); Note* note = notePattern->addNote(Note(MidiTime(4, 0)), false); note->createDetuning(); DetuningHelper* dh = note->detuning(); auto pattern = dh->automationPattern(); pattern->setProgressionType( AutomationPattern::LinearProgression ); pattern->putValue(MidiTime(0, 0), 0.0); pattern->putValue(MidiTime(4, 0), 1.0); QCOMPARE(pattern->valueAt(MidiTime(0, 0)), 0.0f); QCOMPARE(pattern->valueAt(MidiTime(1, 0)), 0.25f); QCOMPARE(pattern->valueAt(MidiTime(2, 0)), 0.5f); QCOMPARE(pattern->valueAt(MidiTime(4, 0)), 1.0f); }
Set<String> ListSymbolsJob::imenu(const std::shared_ptr<Project> &project) { Set<String> out; const List<String> paths = pathFilters(); if (paths.isEmpty()) { error() << "--imenu must take path filters"; return out; } for (int i=0; i<paths.size(); ++i) { const Path file = paths.at(i); if (!file.isFile()) { error() << "Invalid path filter for --imenu" << file; continue; } const uint32_t fileId = Location::fileId(file); if (!fileId) continue; auto symbols = project->openSymbols(fileId); if (!symbols) continue; const int count = symbols->count(); for (int j=0; j<count; ++j) { const Symbol &symbol = symbols->valueAt(j); if (RTags::isReference(symbol.kind)) continue; switch (symbol.kind) { case CXCursor_VarDecl: case CXCursor_ParmDecl: case CXCursor_InclusionDirective: case CXCursor_EnumConstantDecl: break; case CXCursor_ClassDecl: case CXCursor_StructDecl: case CXCursor_ClassTemplate: if (!symbol.isDefinition()) break; // fall through default: { const String &symbolName = symbol.symbolName; if (!string.isEmpty() && !symbolName.contains(string)) continue; out.insert(symbolName); break; } } } } return out; }