HNumber Functions::Private::average( Function *, const QVector<HNumber> & args )
{
if ( args.count() <= 0 )
return HNumber("NaN");
HNumber result = args[0];
for ( int c = 1; c < args.count(); c++ )
result = result + args[c];
result = result / HNumber(args.count());
return result;
}
HNumber Functions::Private::bin( Function *, const QVector<HNumber> & args )
{
if ( args.count() != 1 )
return HNumber("NaN");
HNumber result = args[0];
result.setFormat( 'b' );
return result;
}
HNumber function_geomean(Function* f, const Function::ArgumentList& args)
{
ENSURE_POSITIVE_ARGUMENT_COUNT();
HNumber result = std::accumulate(args.begin(), args.end(), HNumber(1),
std::multiplies<HNumber>());
if (result <= HNumber(0))
return HNumber("NaN");
if (args.count() == 1)
return result;
if (args.count() == 2)
return HMath::sqrt(result);
return HMath::exp(HMath::ln(result) / HNumber(args.count()));
}
BitWidget::BitWidget(int bitPosition, QWidget* parent)
: QLabel(parent),
m_state(false)
{
setFixedSize(SizePixels, SizePixels);
HNumber number(HMath::raise(HNumber(2), bitPosition));
setToolTip(QString("2<sup>%1</sup> = %2")
.arg(bitPosition)
.arg(HMath::format(number, 'd')));
}
HNumber Functions::Private::product( Function *, const QVector<HNumber> & args )
{
if ( args.count() <= 0 )
return HNumber(0);
HNumber result = args[0];
for ( int c = 1; c < args.count(); c++ )
result = result * args[c];
return result;
}
HNumber function_absdev(Function* f, const Function::ArgumentList& args)
{
ENSURE_POSITIVE_ARGUMENT_COUNT();
HNumber mean = function_average(f, args);
if (mean.isNan())
return HMath::nan();
HNumber acc = 0;
for (int i = 0; i < args.count(); ++i)
acc += HMath::abs(args.at(i) - mean);
return acc / HNumber(args.count());
}
HNumber function_median(Function* f, const Function::ArgumentList& args)
{
ENSURE_POSITIVE_ARGUMENT_COUNT();
Function::ArgumentList sortedArgs = args;
qSort(sortedArgs);
if ((args.count() & 1) == 1)
return sortedArgs.at((args.count() - 1) / 2);
const int centerLeft = args.count() / 2 - 1;
return (sortedArgs.at(centerLeft) + sortedArgs.at(centerLeft + 1)) / HNumber(2);
}
HNumber Functions::Private::geomean( Function *, const QVector<HNumber> & args )
{
if ( args.count() <= 0 )
return HNumber("NaN");
HNumber result = args[0];
for ( int c = 1; c < args.count(); c++ )
result = result * args[c];
if ( result <= HNumber(0))
return HNumber("NaN");
if ( args.count() == 1 )
return result;
if ( args.count() == 2 )
return HMath::sqrt( result );
result = HMath::exp( HMath::ln(result) / HNumber(args.count()) );
return result;
}
HNumber Function::exec( const QVector<HNumber> & args )
{
d->error = QString();
if ( ! d->ptr )
{
setError( QString("error"), QString( Functions::tr(
"cannot execute function %1") ).arg( name() ) );
return HNumber(0);
}
if ( d->argc >= 0 && args.count() != d->argc )
{
if ( d->argc == 1 )
setError( d->name, QString( Functions::tr(
"function accepts 1 argument" ) ) );
else
setError( d->name, QString( Functions::tr(
"function accepts %1 arguments" ) ).arg( d->argc ) );
return HNumber(0);
}
return (*d->ptr)( this, args );
}
HNumber Functions::Private::sqrt( Function * f, const QVector<HNumber> & args )
{
if ( args.count() != 1 )
return HNumber::nan();
HNumber num = args[0];
if( num < HNumber(0) )
{
f->setError( f->name(), Functions::tr(
"function undefined for specified argument" ) );
return HNumber::nan();
}
return HMath::sqrt( num );
}
HNumber function_round(Function* f, const Function::ArgumentList& args)
{
ENSURE_EITHER_ARGUMENT_COUNT(1, 2);
HNumber num = args.at(0);
if (args.count() == 2) {
HNumber argPrecision = args.at(1);
if (argPrecision != 0) {
if (!argPrecision.isInteger()) {
f->setError(OutOfDomain);
return HMath::nan();
}
int prec = argPrecision.toInt();
if (prec)
return HMath::round(num, prec);
// The second parameter exceeds the integer limits.
if (argPrecision < 0)
return HNumber(0);
return num;
}
}
return HMath::round(num);
}
HNumber Functions::Private::round( Function * f, const QVector<HNumber> & args )
{
int nArgs = args.count();
if ( nArgs != 1 && nArgs != 2 )
{
f->setError( f->name(), Functions::tr(
"function requires 1 or 2 arguments" ) );
return HNumber::nan();
}
HNumber num = args[0];
if( nArgs == 2){
int prec = 0;
HNumber argprec = args[1];
if (argprec != 0)
{
if( !argprec.isInteger() )
{
f->setError( f->name(), Functions::tr(
"function undefined for specified arguments" ) );
return HNumber::nan();
}
if ((prec = argprec.toInt()) != 0)
return HMath::round( num, prec );
// the 2. parameter exceeds the integer limits
if (argprec < 0)
return HNumber(0);
return num;
}
}
return HMath::round( num );
}
HNumber function_average(Function* f, const Function::ArgumentList& args)
{
ENSURE_POSITIVE_ARGUMENT_COUNT();
return std::accumulate(args.begin(), args.end(), HNumber(0)) / HNumber(args.count());
}
HNumber function_xor(Function* f, const Function::ArgumentList& args)
{
ENSURE_POSITIVE_ARGUMENT_COUNT();
return std::accumulate(args.begin(), args.end(), HNumber(0),
std::mem_fun_ref(&HNumber::operator^));
}
HNumber function_bin(Function* f, const Function::ArgumentList& args)
{
ENSURE_ARGUMENT_COUNT(1);
return HNumber(args.at(0)).setFormat('b');
}
HNumber function_product(Function* f, const Function::ArgumentList& args)
{
ENSURE_POSITIVE_ARGUMENT_COUNT();
return std::accumulate(args.begin(), args.end(), HNumber(1), std::multiplies<HNumber>());
}
