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_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 Functions::Private::lg( Function * f, const QVector<HNumber> & args )
{
if ( args.count() != 1 )
return HNumber::nan();
HNumber x = args[0];
HNumber result = HMath::lg( x );
if ( result.isNan() )
f->setError( f->name(), Functions::tr(
"function undefined for specified argument" ) );
return result;
}
HNumber Functions::Private::nPr( Function * f, const QVector<HNumber> & args )
{
if ( args.count() != 2 )
return HNumber::nan();
// n = args[0]; r = args[1]
HNumber result = HMath::nPr( args[0], args[1] );
// FIX ME: overflow causes a NaN, too, so the message is sometimes
// misleading
if ( result.isNan() )
f->setError( f->name(), Functions::tr(
"function undefined for specified arguments" ) );
return result;
}
HNumber Functions::Private::erfc( Function * f, const QVector<HNumber> & args )
{
if ( args.count() != 1 )
return HNumber::nan();
HNumber x = args[0];
HNumber result = HMath::erfc( x );
if ( result.isNan() && ! x.isNan() )
{
f->setError( f->name(), Functions::tr(
"underflow" ) );
}
return result;
}
HNumber Functions::Private::poicdf( Function * f,
const QVector<HNumber> & args )
{
if ( args.count() != 2 )
return HNumber::nan();
HNumber k = args[0];
HNumber l = args[1];
HNumber result = HMath::poissonCdf( k, l );
if ( result.isNan() )
f->setError( f->name(), Functions::tr(
"function undefined for specified arguments" ) );
return result;
}
HNumber Functions::Private::binomvar( Function * f,
const QVector<HNumber> & args )
{
if ( args.count() != 2 )
return HNumber::nan();
HNumber n = args[0];
HNumber p = args[1];
HNumber result = HMath::binomialVariance( n, p );
if ( result.isNan() )
f->setError( f->name(), Functions::tr(
"function undefined for specified arguments" ) );
return result;
}
HNumber Functions::Private::hypervar( Function * f,
const QVector<HNumber> & args )
{
if ( args.count() != 3 )
return HNumber::nan();
HNumber N = args[0];
HNumber M = args[1];
HNumber n = args[2];
HNumber result = HMath::hypergeometricVariance( N, M, n );
if ( result.isNan() )
f->setError( f->name(), Functions::tr(
"function undefined for specified arguments" ) );
return result;
}
HNumber Functions::Private::csc( Function * f, const QVector<HNumber> & args )
{
if ( args.count() != 1 )
return HNumber::nan();
HNumber angle = args[0];
if ( f->functions()->angleMode() == 'd' )
angle = HMath::deg2rad( angle );
HNumber result = HMath::csc( angle );
if ( result.isNan() )
{
f->setError( f->name(), Functions::tr(
"function undefined for specified argument" ) );
return HNumber::nan();
}
return result;
}
void ResultDisplay::append(const QString& expression, const HNumber& value)
{
++m_count;
appendPlainText(expression);
if (!value.isNan())
appendPlainText(QLatin1String("= ") + NumberFormatter::format(value));
appendPlainText(QLatin1String(""));
// TODO: Refactor, this only serves to save a session.
m_expressions.append(expression);
if (value.isNan()) {
m_results.append("");
} else {
const char format = value.format() != 0 ? value.format() : 'e';
char* str = HMath::format(value, format, DECPRECISION);
m_results.append(str);
free(str);
}
}
void BitFieldWidget::updateBits(const HNumber& number)
{
QString binaryNumberString = HMath::format(number, 'b');
QListIterator<BitWidget*> bitsIterator(m_bitWidgets);
if (number.isZero() || !number.isInteger())
binaryNumberString.clear();
else if (number.isNegative())
binaryNumberString.remove(0, 3); // Remove '-0b'.
else
binaryNumberString.remove(0, 2); // Remove '0b'.
QString::ConstIterator iterator = binaryNumberString.end();
while (bitsIterator.hasNext()) {
if (iterator != binaryNumberString.begin()) {
--iterator;
bitsIterator.next()->setState(*iterator == '1');
} else
bitsIterator.next()->setState(false);
}
}
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);
}
void Editor::autoCalcSelection()
{
if (!m_isAutoCalcEnabled)
return;
const QString str = m_evaluator->autoFix(textCursor().selectedText());
if (str.isEmpty())
return;
// Very short (just one token) and still no calculation, then skip.
if (!m_isAnsAvailable) {
const Tokens tokens = m_evaluator->scan(text());
if (tokens.count() < 2)
return;
}
// Too short even after autofix? Don't bother either.
const Tokens tokens = m_evaluator->scan(str);
if (tokens.count() < 2)
return;
// Same reason as above, do not update "ans".
m_evaluator->setExpression(str);
const HNumber num = m_evaluator->evalNoAssign();
if (m_evaluator->error().isEmpty()) {
if (num.isNan() && m_evaluator->isUserFunctionAssign()) {
// Result is not always available when assigning a user function.
const QString message = tr("Selection result: n/a");
emit autoCalcEnabled(message);
} else {
const QString message = tr("Selection result: <b>%1</b>").arg(NumberFormatter::format(num));
emit autoCalcEnabled(message);
}
} else
emit autoCalcEnabled(m_evaluator->error());
}
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 );
}
