C++ Interval::start方法代碼示例

// Split this interval at pos and return the rest. Pos must be a location
// that ensures both shorter intervals are nonempty. If keep_uses is set,Uses
// exactly at the end of the first interval will stay with the first part.
Interval* Interval::split(unsigned pos, bool keep_uses) {
  assert(pos > start() && pos < end()); // both parts will be non-empty
  auto leader = this->leader();
  Interval* child = smart_new<Interval>(leader);
  child->next = next;
  next = child;
  // advance r1 to the first range we want in child; maybe split a range.
  auto r1 = ranges.begin(), r2 = ranges.end();
  while (r1->end <= pos) r1++;
  if (pos > r1->start) { // split r at pos
    child->ranges.push_back({pos, r1->end});
    r1->end = pos;
    r1++;
  }
  child->ranges.insert(child->ranges.end(), r1, r2);
  ranges.erase(r1, r2);
  // advance u1 to the first use position in child, then copy u1..end to child.
  auto u1 = uses.begin(), u2 = uses.end();
  if (keep_uses) {
    while (u1 != u2 && u1->pos <= end()) u1++;
  } else {
    while (u1 != u2 && u1->pos < child->start()) u1++;
  }
  child->uses.insert(child->uses.end(), u1, u2);
  uses.erase(u1, u2);
  return child;
}

void bisectionMethod(Interval const &interval, double const &eps) {
	double left = interval.start();
	double right = interval.end();
	double middle = (right + left) / 2;

	int n = 0;

	while (abs(left - right) > 2 * eps) {
		if (FuncClass::func(left) * FuncClass::func(middle) > 0)
			left = middle;
		else
			right = middle;
		middle = (right + left) / 2;
		
		n++;
	}

	cout << "Bisection method\n";
	cout << "Step: " << n << "\n";
	cout << "Approximated solution: " << middle << "\n";
	cout << "Discrepansy module: " << abs(FuncClass::func(middle)) << "\n\n";
}

// Note: this is considerably more efficient in the case where intervals are added
// smallest first.
void IntervalList::addInterval(Interval interval)
{
  if(m_list.size() == 0)
  {
    m_list.append(interval);
    return;
  }
  
  bool added = false;
  QList<int> deleteList;

  for(int i = m_list.size() - 1; i >= 0 ; i--)
  {
    // if new interval is completely higher than this interval
    if(interval.start() > m_list.at(i).end() + 1)
    {
      // add new interval as a seperate interval
      m_list.append(interval);
      added = true;
      break;
    }
    // else if the new interval can be merged with this interval
    else if(m_list.at(i).canMerge(interval))
    {
      // for each interval in the list before and including this one
      for(int j = i; j >= 0; j--)
      {
        // if it can be merged into the new interval
        if(m_list.at(j).canMerge(interval))
        {
          // do it
          interval.merge(m_list.at(j));
          // then add its index to the list of intervals to be deleted
          deleteList.append(j);
        }
        // else if it cant, there is no need to continue checking whether 
        // any other intervals can alse be merged
        else
        {
          break;
        }
      }
      // insert the new large interval in the correct place
      m_list.insert(i+1, interval);
      added = true;
      break;
    }
  }
  // if deleteList has any elements, delete intervals at those indices
  if(deleteList.size() > 0)
  {
    qSort(deleteList);
      
    for(int i = deleteList.size() - 1; i >=0 ; i--)
    {
      m_list.removeAt(deleteList[i]);
    }
  }
  // if still not assigned, add to the beginning 
  if(!added)
  {
    m_list.insert(0, interval);
  }
}

    bool Solver::calcStabilityForRowC()
    {
        m_stabilityRowC.resize(m_width, Interval());
        for(size_t j=0; j < m_width; j++)
        {
            Interval vals;

            if(m_variableType[j] == VariableMain)
            {
                size_t basisi;
                for(basisi=0; basisi < m_height; basisi++)
                {
                    if(m_columnBasis[basisi] == j)
                        break;
                }

                // basis variable
                if(basisi != m_height)
                {
                    // we can't change basis variables without changing rowD
                    vals.setStart(0);
                    vals.setEnd(0);

                    /*
                    for(size_t jj=0; jj < m_width; jj++)
                    {
                        if(checkEquals(m_rowD[jj], 0.0) ||
                           checkEquals(m_matrixA[basisi][jj], 0.0))
                            continue;

                        double deltac = m_rowD[jj] / m_matrixA[basisi][jj];

                        if(m_funcType == OptimizeToMin)
                            deltac = -deltac;

                        if(deltac < 0)
                        {
                            if(deltac > vals.start())
                                 vals.setStart(deltac);
                        }
                        else if(deltac > 0)
                        {
                            if(deltac < vals.end())
                                 vals.setEnd(deltac);
                        }
                    }*/
                }
                else // free variable
                {
                    double deltac = m_rowD[j];

                    if(m_funcType == OptimizeToMax)
                        deltac = -deltac;

                    if(deltac > 0)
                        vals.setEnd(deltac);
                    else if(deltac < 0)
                        vals.setStart(deltac);
                    else
                    {
                        vals.setStart(deltac);
                        vals.setEnd(deltac);
                    }
                }

                vals.setStart(m_rowC[j] + vals.start());
                vals.setEnd(m_rowC[j] + vals.end());
            }

            m_stabilityRowC[j] = vals;
        }

        return true;
    }

void check_interval(const Interval& actual, const Interval& truth) {
  BOOST_CHECK_EQUAL(actual.chr(), truth.chr());
  BOOST_CHECK_EQUAL(actual.start(), truth.start());
  BOOST_CHECK_EQUAL(actual.stop(), truth.stop());
}

string ReferenceMap::get_sequence(const Interval& interval, const bool reverse_strand) const {
  const auto& seq = this->at(interval.chr());
  auto result = seq.substr(interval.start()-1, interval.size());
  return reverse_strand ? utils::complement(result) : result;
}