Пример #1
0
void KDoubleSpinBox::updateValidator() {
  if ( !d->mValidator ) {
    d->mValidator =  new KDoubleSpinBoxValidator( minValue(), maxValue(), precision(),
					   this, "d->mValidator" );
    base::setValidator( d->mValidator );
  } else
    d->mValidator->setRange( minValue(), maxValue(), precision() );
}
Пример #2
0
 string asset::to_string()const {
    string result = fc::to_string(amount.value / precision());
    if( decimals() )
    {
       auto fract = amount.value % precision();
       result += "." + fc::to_string(precision() + fract).erase(0,1);
    }
    return result + " " + symbol_name();
 }
bool QgsRendererRangeV2LabelFormat::operator==( const QgsRendererRangeV2LabelFormat &other ) const
{
  return
    format() == other.format() &&
    precision() == other.precision() &&
    trimTrailingZeroes() == other.trimTrailingZeroes();
}
Пример #4
0
/* encode contiguous floating-point block */
uint
_t2(zfp_encode_block, Scalar, DIMS)(zfp_stream* zfp, const Scalar* fblock)
{
  /* compute maximum exponent */
  int emax = _t1(exponent_block, Scalar)(fblock, BLOCK_SIZE);
  int maxprec = precision(emax, zfp->maxprec, zfp->minexp, DIMS);
  uint e = maxprec ? emax + EBIAS : 0;
  /* encode block only if biased exponent is nonzero */
  if (e) {
    cache_align_(Int iblock[BLOCK_SIZE]);
    /* encode common exponent; LSB indicates that exponent is nonzero */
    int ebits = EBITS + 1;
    stream_write_bits(zfp->stream, 2 * e + 1, ebits);
    /* perform forward block-floating-point transform */
    _t1(fwd_cast, Scalar)(iblock, fblock, BLOCK_SIZE, emax);
    /* encode integer block */
    return ebits + _t2(encode_block, Int, DIMS)(zfp->stream, zfp->minbits - ebits, zfp->maxbits - ebits, maxprec, iblock);
  }
  else {
    /* write single zero-bit to indicate that all values are zero */
    stream_write_bit(zfp->stream, 0);
    if (zfp->minbits > 1) {
      stream_pad(zfp->stream, zfp->minbits - 1);
      return zfp->minbits;
    }
    else
      return 1;
  }
}
Пример #5
0
 MessageHandler_()
         : std::ostream(new Buf(*this)), indent(indentLevel * INDENT_SIZE),
           beginLine(0), stepCount(0) {
     flags(os.flags());
     precision(os.precision());
     width(os.width());
 }
void CardTableModRefBSForCTRS::non_clean_card_iterate_possibly_parallel(
  Space* sp,
  MemRegion mr,
  OopsInGenClosure* cl,
  CardTableRS* ct,
  uint n_threads)
{
  if (!mr.is_empty()) {
    if (n_threads > 0) {
#if INCLUDE_ALL_GCS
      non_clean_card_iterate_parallel_work(sp, mr, cl, ct, n_threads);
#else  // INCLUDE_ALL_GCS
      fatal("Parallel gc not supported here.");
#endif // INCLUDE_ALL_GCS
    } else {
      // clear_cl finds contiguous dirty ranges of cards to process and clear.

      // This is the single-threaded version used by DefNew.
      const bool parallel = false;

      DirtyCardToOopClosure* dcto_cl = sp->new_dcto_cl(cl, precision(), cl->gen_boundary(), parallel);
      ClearNoncleanCardWrapper clear_cl(dcto_cl, ct, parallel);

      clear_cl.do_MemRegion(mr);
    }
  }
}
Пример #7
0
double ConfusionMatrix::fscore(int category) {
  double p = precision(category);
  double r = recall(category);
  if((p + r) == 0.0)
    return 0.0;
  return (2 * p * r) / (p + r);
}
Пример #8
0
AplusFuncLabel::AplusFuncLabel(A a_, AplusLabelOut *alo_) : AplusLabelOut()
{
  if (alo_!=0 && alo_->outFunc()!=0)
   {
     outFunc(alo_->outFunc());
     v(alo_->v());
   }

  if (alo_!=0 && alo_->format()!=AplusFormatter::BadFormat)
   {
     format(alo_->format());
     precision(alo_->precision());
   }

  if (verify(a_)==MSTrue)
   {
     a((A) ic(a_));
   }
  else
   {
     MSStringVector emptyStringVector;
     a((A)0);
     tick((A)0);
     grid((A)0);
     value((A)0);
     labels(emptyStringVector);
   }
}
Пример #9
0
 // network specific types
 int operator()(Layout_type const* t)
 {
   int n = 0;
   for (Decl* d : t->declaration()->fields())
     n += precision(d->type());
   return n;
 }
Пример #10
0
void		ft_putloo(va_list ap)
{
	char				*str;

	if ((g_trait & OPT_J) == OPT_J)
		str = ft_putjo(ap);
	else if (g_trait & OPT_Z)
		str = ft_putzo(ap);
	else if ((g_trait & OPT_LL) == OPT_LL)
		str = ft_putllo(ap);
	else if ((g_trait & OPT_L) == OPT_L)
		str = ft_putlo(ap);
	else if ((g_trait & OPT_HH) == OPT_HH)
		str = ft_puthho(ap);
	else if ((g_trait & OPT_H) == OPT_H)
		str = ft_putho(ap);
	else
		str = ft_putosf(ap);
	str = precision(str, 8);
	if (ft_strcmp(str, "") == 0 && g_trait & OPT_DIESE)
		str = ft_strdup("0");
	str = treat_o(str);
	g_print += ft_strlen(str);
	ft_putstr_fd(str, g_fd);
	free(str);
}
Пример #11
0
void CLabHorizScale::drawScale(CDC *pDC)
{
   int tickLength;
   
   CRgn rgn;
   CRect rect = bounds();
   rgn.CreateRectRgn(rect.left, rect.top, rect.right, rect.bottom);
   pDC->SelectClipRgn(&rgn);
      
   for(double x=getTickMin(); x<=maximum(); x=x+tickIncrement())
   {
      double temp = x/(majorTickFrequency()*tickIncrement());
      if(temp == ceil(temp))
         tickLength = 7;
      else
         tickLength = 3;


      pDC->MoveTo(translateCoordinate(x), rect.top);
      pDC->LineTo(translateCoordinate(x), rect.top + tickLength);

      temp = x/(tickMarkFrequency() * tickIncrement());
      if(temp == ceil(temp))
      {
         CString tickMarkStr;
         tickMarkStr.Format("%.*f", precision(), x);
         
         pDC->TextOut(translateCoordinate(x) - _parent->getCharWidth() * tickMarkStr.GetLength()/2, 
                      rect.top + 7 /* _parent->getCharHeight()*/, 
                      tickMarkStr);

      }
   }
}
Пример #12
0
 MessageHandler_()
         : std::ostream(&buf), buf(*this), indent(indentLevel * INDENT_SIZE),
           beginLine(0), totalSteps(0), stepCount(0),
           dotCount(0), dotTime(0), stepping(false) {
     flags(os.flags());
     precision(os.precision());
     width(os.width());
 }
 model::AssetResponse PbQueryResponseFactory::deserializeAssetResponse(
     const protocol::AssetResponse &response) const {
   model::AssetResponse res;
   auto asset = response.asset();
   res.asset =
       Asset(asset.asset_id(), asset.domain_id(), asset.precision());
   return res;
 }
Пример #14
0
double CoverMetrics::f1score() const {
    double p = precision();
    double r = recall();
    if (p + r < std::numeric_limits<double>::epsilon()) {
        return std::sqrt(-1); // return NaN
    }
    return 2*p*r/(p + r);
}
 basic_ios& copyfmt(const ios& right) {
     fill(right.fill());
     flags(right.flags() );
     exceptions(right.exceptions());
     width(right.width());
     precision(right.precision());
     return *this;
 }
Пример #16
0
 /**
  * Stringify the data.
  * @return the content of asset.
  */
 std::string toString() const override {
   return detail::PrettyStringBuilder()
       .init("Asset")
       .append("assetId", assetId())
       .append("domainId", domainId())
       .append("precision", std::to_string(precision()))
       .finalize();
 }
Пример #17
0
//------------------------------------------------------------------------------
void ostream::putDouble(double n) {
  uint8_t nd = precision();
  double round = 0.5;
  char sign;
  char buf[13];  // room for sign, 10 digits, '.', and zero byte
  char *end = buf + sizeof(buf) - 1;
  char *str = end;
  // terminate string
  *end = '\0';

  // get sign and make nonnegative
  if (n < 0.0) {
    sign = '-';
    n = -n;
  } else {
    sign = flags() & showpos ? '+' : '\0';
  }
  // check for larger than uint32_t
  if (n > 4.0E9) {
    pgm err(PSTR("BIG FLT"));
    putPgm(err);
    return;
  }
  // round up and separate in and fraction parts
  for (uint8_t i = 0; i < nd; ++i) round *= 0.1;
  n += round;
  uint32_t intPart = n;
  double fractionPart = n - intPart;

  // format intPart and decimal point
  if (nd || (flags() & showpoint)) *--str = '.';
  str = fmtNum(intPart, str, 10);

  // calculate length for fill
  uint8_t len = sign ? 1 : 0;
  len += nd + end - str;

  // extract adjust field
  fmtflags adj = flags() & adjustfield;
  if (adj == internal) {
    if (sign) putch(sign);
    do_fill(len);
  } else {
    // do fill for internal or right
    fill_not_left(len);
    if (sign) *--str = sign;
  }
  putstr(str);
  // output fraction
  while (nd-- > 0) {
    fractionPart *= 10.0;
    int digit = static_cast<int>(fractionPart);
    putch(digit + '0');
    fractionPart -= digit;
  }
  // do fill if not done above
  do_fill(len);
}
Пример #18
0
 SVOutStream::SVOutStream(ostream& out, const String& sep,
                          const String& replacement,
                          String::QuotingMethod quoting) :
   ostream(out.rdbuf()), sep_(sep), replacement_(replacement), nan_("nan"),
   inf_("inf"), quoting_(quoting), modify_strings_(true), newline_(true)
 {
   // use high decimal precision (appropriate for double):
   precision(std::numeric_limits<double>::digits10);
 }
Пример #19
0
ACE_UINT32
ACE_Stats_Value::fractional_field (void) const
{
  if (precision () == 0)
    {
      return 1;
    }
  else
    {
      ACE_UINT32 field = 10;
      for (u_int i = 0; i < precision () - 1; ++i)
        {
          field *= 10;
        }

      return field;
    }
}
Пример #20
0
void writeLogfileEntry(std::ofstream &ofLog, const std::string &sFilename, int tp, int fp, int fn)
{
    ofLog << sFilename << std::endl;
    ofLog << "# faces: " << tp+fn;
    ofLog << ", # detected faces: " << tp+fp << std::endl;
    ofLog << "tp = " << tp << ", fp = " << fp << ", fn = " << fn;
    ofLog << ", pr = " << precision(tp, fp);
    ofLog << ", rc = " << recall(tp, fn) << std::endl;
    ofLog.flush();
}
Пример #21
0
bool UVSphere::hit(const Ray& r, precision tMin, precision tMax, precision time, HitRecord& record) const{
    Vector3 temp = r.origin() - center;
    
    double a = dot(r.direction(), r.direction());
    double b = 2 * dot(r.direction(), temp);
    double c = dot(temp, temp) - radius * radius;
    
    double discriminant = b * b - 4 * a * c;
    
    //First check to see if the ray intersects the sphere
    if(discriminant > 0){
        discriminant = sqrt(discriminant);
        double t = (- b - discriminant) / (2 * a);
        
        //Now check for a valid interval
        if(t < tMin)
            t = (- b + discriminant) / (2 * a);
        if(t < tMin || t > tMax)
            return false;
        
        //We have a valid hit
        record.t = (precision)t;
        record.hitP = (r.origin() + (precision)t * r.direction());
        //record.normal = unitVector(r.origin() + (precision)t * r.direction() - center);
        Vector3 n = record.normal = (record.hitP - center) / radius;
        
        //Calculate UV coordinates
        precision twopi = precision(2 * M_PI);
        precision one_over_2pi = precision(M_1_PI / 2) ;
        precision theta = acos(n.z());
        precision phi   = atan2(n.y(), n.x());
        if (phi < 0.0f)
            phi += twopi;
        
        record.uv = Vector2(precision(phi * one_over_2pi), precision((M_PI - theta) * M_1_PI));
        return true;
    }
    
    return false;
}
Пример #22
0
string asset::to_string() const {
    int64_t prec = precision();
    string result = fc::to_string(amount.value / prec);
    if (prec > 1) {
        auto fract = amount.value % prec;
        // prec is a power of ten, so for example when working with
        // 7.005 we have fract = 5, prec = 1000.  So prec+fract=1005
        // has the correct number of zeros and we can simply trim the
        // leading 1.
        result += "." + fc::to_string(prec + fract).erase(0, 1);
    }
    return result + " " + symbol_name();
}
Пример #23
0
pgsOperand pgsGenReal::eval(pgsVarMap &vars) const
{
	// Evaluate parameters
	pgsOperand min(m_min->eval(vars));
	pgsOperand max(m_max->eval(vars));
	pgsOperand precision(m_precision->eval(vars));
	pgsOperand sequence(m_sequence->eval(vars));
	pgsOperand seed(m_seed->eval(vars));

	// Check parameters and create the generator
	if (min->is_number() && max->is_number() && sequence->is_integer()
	        && seed->is_integer() && precision->is_integer())
	{
		long aux_sequence, aux_seed, aux_precision;
		sequence->value().ToLong(&aux_sequence);
		seed->value().ToLong(&aux_seed);
		precision->value().ToLong(&aux_precision);
		return pnew pgsGenerator(pgsVariable::pgsTReal,
		                         pnew pgsRealGen(pgsVariable::num(min), pgsVariable::num(max), aux_precision,
		                                 aux_sequence != 0, aux_seed));
	}
	else
	{
		// Deal with errors
		if (!min->is_number())
		{
			throw pgsParameterException(wxString() << value()
			                            << wxT(":\nmin should be a number"));
		}
		else if (!max->is_number())
		{
			throw pgsParameterException(wxString() << value()
			                            << wxT(":\nmax should be a number"));
		}
		else if (!precision->is_integer())
		{
			throw pgsParameterException(wxString() << value()
			                            << wxT(":\nprecision should be an integer"));
		}
		else if (!sequence->is_integer())
		{
			throw pgsParameterException(wxString() << value()
			                            << wxT(":\nsequence should be an integer"));
		}
		else
		{
			throw pgsParameterException(wxString() << value()
			                            << wxT(":\nseed should be an integer"));
		}
	}
}
Пример #24
0
AplusFormatLabelOut::AplusFormatLabelOut(AplusFormatter::OutputFormat format_,
					 int precision_, AplusLabelOut *alo_)
  : AplusLabelOut()
{
  format(format_);
  precision(precision_);
  if (alo_!=0 && alo_->a()!=0)
   {
     a((A)ic(alo_->a()));
     tick(alo_->tick());
     grid(alo_->grid());
     value(alo_->value());
   }
}
Пример #25
0
bool Matrix::operator==(const Matrix& m) const
{
    if(size() != m.size())
    {
        return false;
    }

    if(precision() != m.precision())
    {
        return false;
    }

    return reduce(apply(*this, m, NotEqual()), {}, Add())[0] == 0;
}
Пример #26
0
    /**
     * \return Log of the probability of the given sample \c vector
     *
     * \param vector sample which should be evaluated
     *
     * \throws see has_full_rank()
     */
    Real log_probability(const Variate& vector) const override
    {
        // assert(has_full_rank());

        if(has_full_rank())
        {
            return log_normalizer() - 0.5
                    * (vector - mean()).transpose()
                    * precision()
                    * (vector - mean());
        }

        return -std::numeric_limits<Real>::infinity();
    }
 // function: sig_fig
 // -------------------
 REAL_TYPE sig_fig(REAL_TYPE x, int sigFigs) throw(std::invalid_argument)
 {
     if(sigFigs <= 0) throw(std::invalid_argument("sig_fig(): sigFigs must be greater than 0."));
 
     int sign;
 	if(x < 0.0)
 		sign = -1;
 	else
 		sign = 1;
 
     x = std::abs(x);
     REAL_TYPE powers = std::pow(10.0, std::floor(std::log10(x)) + 1.0);
     
     return sign * precision(x / powers, sigFigs) * powers;
 }
Пример #28
0
        //! @{
        virtual void compute_nodes() override
        {
          this->nodes = vector<precision>(this->num_nodes, precision(0.0));
          auto l   = Polynomial<precision>::legendre(this->num_nodes);
          auto lm1 = Polynomial<precision>::legendre(this->num_nodes - 1);

          for (size_t i = 0; i < this->num_nodes; i++) {
            l[i] += lm1[i];
          }
          auto roots = l.roots();
          for (size_t j = 1; j < this->num_nodes; j++) {
            this->nodes[j - 1] = 0.5 * (1.0 - roots[this->num_nodes - j]);
          }
          this->nodes.back() = 1.0;
        }
Пример #29
0
void ConfusionMatrix::print_summary() {
  // overall counts and summary
  cout.precision(4);
  cout << "== Summary ==" << endl;
  cout << setw(23) <<"Correctly classified:" << setw(12) << right << correct << setw(10) << right << accuracy() * 100 << "%" << endl;
  cout << setw(23) << "Incorrectly classified:" << setw(12) << right << incorrect << setw(10) << right << error() * 100 << "%" << endl;
  cout << setw(23) << "Total classifications:" << setw(12) << right << correct + incorrect << endl << endl;
  
  // determine the width of the left (category name) column
  int max_name_length = 0;
  for(int category = 1; category <= data_set->categories_size(); category++)
    if(data_set->category_feature()->names[category].length() > max_name_length)
      max_name_length = data_set->category_feature()->names[category].length();
  if(average_row_name.length() > max_name_length)
    max_name_length = average_row_name.length();
  max_name_length += 1;
  
  // detailed category information
  cout << "== Category Performance ==" << endl;
  cout << setw(max_name_length) << "";
  cout << setw(9) << right << "True +";
  cout << setw(9) << right << "False +";
  cout << setw(9) << right << "True -";
  cout << setw(9) << right << "False -";
  cout << setw(9) << right << "Precis.";
  cout << setw(9) << right << "Recall";
  cout << setw(9) << right << "F-score" << endl;
  
  for(int category = 1; category <= data_set->categories_size(); category++) {
    cout << setw(max_name_length) << data_set->category_feature()->names[category];
    cout << setw(9) << tp(category);
    cout << setw(9) << fp(category);
    cout << setw(9) << tn(category);
    cout << setw(9) << fn(category);
    cout << setw(8) << precision(category) * 100 << "%";
    cout << setw(8) << recall(category) * 100 << "%";
    cout << setw(8) << fscore(category) * 100 << "%" << endl;
  }
  
  cout << setw(max_name_length) << average_row_name;
  cout << setw(9) << avg_tp();
  cout << setw(9) << avg_fp();
  cout << setw(9) << avg_tn();
  cout << setw(9) << avg_fn();
  cout << setw(8) << avg_precision() * 100 << "%";
  cout << setw(8) << avg_recall() * 100 << "%";
  cout << setw(8) << avg_fscore() * 100 << "%" << endl;
}
Пример #30
0
Foam::ensightFile::ensightFile
(
    const fileName& pathname,
    IOstream::streamFormat format
)
:
    OFstream(pathname, format)
{
    // ascii formatting specs
    setf
    (
        ios_base::scientific,
        ios_base::floatfield
    );
    precision(5);
}