Softpedia >Linux >Utilities >Qalculate! >  Changelog

Qalculate! Changelog

What's new in Qalculate! 5.0.0

Mar 11, 2024
  • Click on binary digit in result to flip bit
  • Selection of default number of bits for binary and hexadecimal numbers in programming keypad
  • Always show binary position numbers in result if numbers of bits are higher than 16, and improve appearance
  • Improvements/fixes to conversion completion and menus
  • Add retry and cancel buttons to error dialog after failure to save preferences, definitions, or workspace
  • Add last result to stack when pressing Enter with empty expression (was unintentionally disabled)
  • Selection of default number of bits for binary and hexadecimal numbers in programming keypad
  • Always show binary position numbers in result if numbers of bits are higher than 16, and improve appearance
  • More rounding methods
  • Support for hexadecimal floating-point literals using 0x...p... notation (0x1.4p3 = 0x1.4 * 2^3 = 10)
  • Use parentheses for number with scientific notation in more cases
  • Fix x and y reversed for paired matrix when using plot dialog
  • Detection of potential spelling mistakes (a warning will be shown) (libqalculate)
  • Add support for n...m, j:k, and j:i:k syntax, for sequence of numbers, e.g. 1...3 = (1:3) = (1:1:3) = [1 2 3] (note that brackets may be required for colon syntax to avoid conflict with time format) (libqalculate)
  • Improved "where" operator, including improved output of parsed expression, support for previously undefined variable names, and assignments before expression (e.g. "a=2, b=2, a^b") (libqalculate)
  • New units: LightSecond, LightMinute, and LightHour (libqalculate)
  • New functions: bitget(), bitset(), setbits(), integerDigits(), digitGet(), digitSet(), flip(), colon(), and foreach() (libqalculate)
  • Add support for "decimals" "to"-conversion (display as decimal fraction) (libqalculate)
  • Allow plot grid values higher than 1 (true) to specify line width (libqalculate)
  • Improve handling of zero solution and initial guess in newtonsolve() and secantsolve(), and check validity of solution (libqalculate)
  • Change handling a vectors in multiple function arguments (of non-vector type) - return vector instead of matrix, require equal number of elements, and use the same vector index for all arguments for each function instance (e.g. atan2([1 2], [3 4]) = [atan2(1, 3) atan(2 4)] (libqalculate)
  • Set handle vector property by default, for text, date, and boolean arguments, and for arguments, in global non-builtin functions, without specified type, and enable parsing of vectors for text arguments (libqalculate)
  • Do not apply "read precision" setting to integer exponents for values with units (libqalculate)
  • Change from line to point (or dot) plot style for data with many discontinuous points (libqalculate)
  • lambertw(x*e^x, 0)=x if x>=-1 (libqalculate)
  • Fix dsolve(diff(y, x) = y), and similar (libqalculate)
  • Fix log(1, 1) (undefined) (libqalculate)
  • Fix "to"-conversion to prefix and add "prefix" conversion option (for optimal prefix) (libqalculate)
  • Fix segfault in newtonsolve() and secantsolve() when equation does not contain variable (libqalculate)
  • Fix conversion to angle unit for complex angle, cis and polar forms (libqalculate)
  • Exchange rates fixes (libqalculate)
  • Minor bug fixes and feature enhancements

New in Qalculate! 4.9.0 (Nov 27, 2023)

  • Qalculate! is a multi-purpose cross-platform desktop calculator. It is simple to use but provides power and versatility normally reserved for complicated math packages, as well as useful tools for everyday needs (such as currency conversion and percent calculation). Features include a large library of customizable functions, unit calculations and conversion, symbolic calculations (including integrals and equations), arbitrary precision, uncertainty propagation, interval arithmetic, plotting, and a user-friendly interface (GTK, Qt, and CLI).
  • CHANGES:
  • Support for specifying a fixed denominator for display of fractions (e.g. "0.3 ft ➞ 1/8 ≈ (3 + 5/8) in")
  • Improve decision to (not) update calculate-as-you-type result when last character is an operator
  • Always add result to history (even if identical to previous) if expression contains a function generating a random number
  • Prefer capitalized function name (over name with underscore), when completing function name
  • Add percent and permille output options in rational number form menu
  • Fix keypad button (up/down) for cycling through expression history
  • Return gcd of numerators divided by lcm of denominators in gcd() with non-integer rational numbers, and vice versa for lcm() (libqalculate)
  • Add units for mean Gregorian and tropical years (libqalculate)
  • Ignore underscore in number (libqalculate)
  • Replace defunct exchange rates source and fix bitcoin exchange rate (libqalculate)
  • Fix asin(x)=a, acos(x)=a, and atan(x)=a, when a contains an angle unit and default angle unit is set (libqalculate)
  • Fix output of value converted to unit expression with numerical multiplier in denominator, e.g. "➞ L/(100 km)" (libqalculate)
  • Fix segfault when trying to solve "(xsqrt(x)-ysqrt(y))/(sqrt(x)-sqrt(y))=x+sqrt(x*y)+y" (libqalculate)
  • Fix parsing of case insensitive object name ending with Unicode character when followed by another Unicode character in expression, e.g. "микрометр" (libqalculate)
  • Minor bug fixes and feature enhancements

New in Qalculate! 4.8.1 (Sep 19, 2023)

  • CHANGES:
  • Fix besselj() and bessely()
  • Fix display of matrices and vectors with complex number form other than rectangular (default)
  • Fix conflict between decibel units (e.g. "0dB") and duodecimal 0d… syntax (now requires at least two digits)
  • Fixes for title options in plot() function
  • Auto-update number bases above programming keypad when entering simple integers, even if calculate-as-you-type is deactivated

New in Qalculate! 4.8.0 (Aug 23, 2023)

  • Update dialogs for editing of variables, functions, units, etc. to match the corresponding dialogs in the Qt UI
  • Show user-defined objects in a separate category in menus and dialogs
  • Add option to disable tooltips in keypad or everywhere
  • Make closing of application with Escape key optional and disabled by default
  • Add Microship (PIC16/17) 24 and 32 bit floating point formats
  • Add support for specifying position of sign bit in floating point functions
  • Concise (e.g. "1.2345(67)") and relative (e.g. "5+/-2%") notation for output and input (disabled by default for concise notation) of interval
  • Optimize rest of unit expression when converting to partial (insufficient) expression (e.g. 18MA×100ns to J = 1.8 J/V)
  • Round high precision intervals enclosing integers for integer arguments
  • New derived units: Debye, C·m, Daraf, F^-1, V/C, N/C, kcal, kcal/g, kJ
  • Use international foot as base unit for rod
  • Fix initial height of list and description in units window
  • Fix fibonacci() for non-integers and recursive use
  • Fix conversion options presented for speed units (and possibly other)
  • Minor bug fixes and feature enhancements

New in Qalculate! 4.7.0 (Jul 4, 2023)

  • Changes:
  • Allow multiple actions for keyboard shortcuts
  • Add toggle precision, and min, max, or min and max decimals to available shortcut and button actions
  • Add option to exclude units for unformatted ASCII copy
  • Add optional value to copy result action, allowing expression copy and formatting selection
  • Fix copy unformatted ASCII when local digit group separator is same as selected decimal separator
  • Support for custom default angle unit, e.g. turn, arcsec, arcmin
  • Append default angle unit (instead of always radians) when converting value without unit to angle unit
  • More consistent addition and removal of angle unit from function arguments
  • Always interpret ./, .*, and .^ as entrywise operators if user intention is unclear
  • Change order of operations to place entrywise and ordinary operators on the same precedence level
  • Add function, kron(), for Kronecker product, and constants for Pauli matrices
  • Add radius to planets dataset and update other properties
  • Support replacement of unknown variables within variable values
  • Fix besselj(0, 0)
  • Fix incomplete calculation in tan() with try exact approximation
  • Fix 0/0=0 equality (do not return true) and output of 2/0 (and similar)
  • Fixes and improvements for newtonsolve() and secantsolve()
  • Fix segfault when MathStructure is deleted after Calculator, and in destructor of calculated DynamicVariable (called from Calculator destructor)
  • Minor bug fixes and feature enhancements

New in Qalculate! 4.6.1 (Apr 18, 2023)

  • CHANGES:
  • Fix segfault in Gnome shell search provider with GLib 2.76 (GTK)
  • Support WebKitGTK version in configure option, e.g. --with-webkitgtk=4.1
  • Improve abortion of slow calculations (libqalculate)
  • Fix segfault and inconsistent behaviour in calculation of a^n mod b when n is negative (libqalculate)
  • Add modular exponentiation function, powmod(), with support for calculation of modular inverse (libqalculate)
  • Do not make any difference between row and column vectors in magnitude(), norm(), and dot() functions (libqalculate)
  • Fix division and exponentiation of scalar by matrix/vector, e.g. 4./[8 4.5] (libqalculate)
  • Improve parsing of element-wise operators with comma as decimal separator (libqalculate)
  • Fix rref() with different units for different elements (libqalculate)
  • Fix segfault with empty vector in uncertainty calculation (libqalculate)
  • Fix segfault trying to solve cbrt(x)^(1/3)-x=0 (libqalculate)
  • Fix segfault in handling of vector variable with uncertainty (libqalculate)
  • Fix segfault in function assignment with equals sign (e.g. F()=...), when an object with the same name already exists (libqalculate)
  • Fix segfaults in some corner cases (libqalculate)
  • Fix internal id does not exist error (libqalculate)
  • Fix erroneous simplification of sin(x)^2*y-cos(x)sin(x)^2y (libqalculate)
  • Do not try to calculate norm() and magnitude() for matrices (libqalculate)
  • Fix some memory leaks (libqalculate)
  • Fix order of argument titles in csum() function (libqalculate)

New in Qalculate! 4.6.0 (Mar 6, 2023)

  • CHANGES:
  • More robust and consistent default language detection and option to change language on Windows
  • Use Unicode symbol for minus in scientific e notation
  • Option to change symbols used for output of digits 10 and 11 in duodecimal numbers (use A and B as default digits)
  • Fixes for output of scientific notation using number bases other than decimal
  • Do not automatically by default set prefix higher than kilo for meter, gram, higher than 1 (no prefix) for second and litre, or lower than 1 for byte and bit (libqalculate)
  • Do not use recently introduced SI prefixes (R, Q, r, q) automatically by default (libqalculate)
  • Do not set automatic prefix if resulting multiplier is less than 1 or greater than 1000, with some exceptions (e.g. km) (libqalculate)
  • Default prefix unit property (use for gram, and few other units, instead of hard coded value) (libqalculate)
  • Allow the same variable left and right of the equals sign (e.g. var=var+2), in variable assignment without colon, if the variable exists and the previous value is known (libqalculate)
  • Do not show multiplier if exactly 1, in HTML output of scientific notation (libqalculate)
  • Prefer Nm (torque) over J when the result is a vector with three components (libqalculate)
  • Add "amp" abbreviation to ampere unit, and "thou" name for 1/1000 in (mil) (libqalculate)
  • Fix unit order for Nm and Ws (libqalculate)
  • Fix conversion from ounce (interpreted as fluid ounce) to litre with prefix (libqalculate)
  • Fix automatic reactivation of global object after deletion of conflicting object (libqalculate)
  • Fix parsing of scientific e notation when the number is extremely large and exponentiation fails because of floating point overflow (libqalculate)
  • Fix prefix selection in denominator when multiplier is higher than the value of the largest prefix (libqalculate)
  • Fix segfault in multisolve() (libqalculate)
  • Minor bug fixes and feature enhancements

New in Qalculate! 4.5.1 (Jan 4, 2023)

  • Qalculate! is a multi-purpose cross-platform desktop calculator. It is simple to use but provides power and versatility normally reserved for complicated math packages, as well as useful tools for everyday needs (such as currency conversion and percent calculation). Features include a large library of customizable functions, unit calculations and conversion, symbolic calculations (including integrals and equations), arbitrary precision, uncertainty propagation, interval arithmetic, plotting, and a user-friendly interface (GTK, Qt, and CLI).
  • CHANGES:
  • Align completion list to beginning of word
  • Fix retrieval of exchange rates from mycurrency.net and add alternative secondary exchange rates sources (libqalculate)
  • Add m/s³, m/s⁴, m/s⁵, and m/s⁶ as derived units (improves automatic unit conversion) (libqalculate)
  • Check that the output of command, in command() function, is a reasonably sane expression (libqalculate)

New in Qalculate! 4.5.0 (Dec 20, 2022)

  • CHANGES:
  • Conversion to any type of expression (e.g. "1000 BTC to million USD")
  • Use current status of limit implicit multiplication setting during parsing of conversion expression
  • New SI prefixes (R, r, Q, q)
  • New units: ounce force (ozf), rack unit (U)
  • Use standard form (sorting) for polynomials
  • Improve consistency of behaviour when global units are replaced
  • More consistent addition of units to expression without units for unit conversion
  • Improvements and fixes for arg() and atan2() functions
  • Use history font for RPN stack list
  • Fix factorization conversion specified in expression, and conversion performed using a separate expression
  • Fix unit names dialog
  • Fix interpretation of Myr (megayear) and Gyr (gigayear)
  • Fix milli- and centimeter of water units
  • Fix genvector() with for negative step size or expression as step size/number of steps
  • Fix randuniform() function
  • Fix automatic/dual fraction format after conversion (e.g. "8 to score")
  • Fix inconsistently displayed parsing of "7d 5h" and similar
  • Fix empty customize keypad buttons dialog when reopened
  • Fixes/improvements for completion menu when opened upwards
  • Minor bug fixes and feature enhancements

New in Qalculate! 4.4.0 (Oct 17, 2022)

  • Qalculate! is a multi-purpose cross-platform desktop calculator. It is simple to use but provides power and versatility normally reserved for complicated math packages, as well as useful tools for everyday needs (such as currency conversion and percent calculation). Features include a large library of customizable functions, unit calculations and conversion, symbolic calculations (including integrals and equations), arbitrary precision, uncertainty propagation, interval arithmetic, plotting, and a user-friendly interface (GTK, Qt, and CLI).
  • Changes:
  • Add "Clear history" to available keyboard shortcut and button actions
  • Show exchange rates source, and update time, for current calculation in tooltip
  • Fix "Set Prefix" for auto-calculated result
  • Fix copying of result during delay before calculate-as-you-type result is added to history
  • Allow use of curly brackets as alternative parentheses
  • New prime number functions: primePi(), primes(), nthprime(), nextprime(), prevprime(), and isprime() (libqalculate)
  • New functions for intervals and uncertainties: upperEndpoint(), lowerEndpoint(), midpoint(), and errorPart() (libqalculate)
  • Add meter of water and related pressure units, and more derived flow rate units (libqalculate)
  • Support for vectors and matrices in uncertainty propagation calculation (libqalculate)
  • Proper support for uncertainty propagation in total(), sum(), product(), and for() functions (libqalculate)
  • Simplify display of parsed expression (primarily for quantities with units) (libqalculate)
  • Avoid parsing of implicit multiplication as nested multiplication (libqalculate)
  • Include +/- statement in function argument without parentheses (libqalculate)
  • Return values for approximate variables in exact mode in dimension() and elements() (libqalculate)
  • Improve parsing of quotation marks as feet/inch or arcmin/arcsec (e.g. do not parse s" as sin) (libqalculate)
  • Fix exact calculation of re((a*i)^(n/2)) (wrong sign in some cases) (libqalculate)
  • Fix erroneous calculation in some cases with physical constants both outside and inside unit relations when interval calculation is set to interval arithmetic (libqalculate)
  • Fix segfaults in some corner cases (libqalculate)
  • Fix use of random numbers in iterative functions (libqalculate)
  • Fix writing beyond end of array during exchange rates check in some cases (results in activation of old style matrices) (libqalculate)
  • Fix automatic reactivation of deactivated global object if a function with the same name exists (libqalculate)
  • Do not convert function arguments which do not allow units (fixes "arcsin(0.5+/-0.1) to deg") (libqalculate)
  • Fix prefix after conversion to optimal unit when the optimal unit includes a prefix (libqalculate)
  • Fix exact calculation when function argument is an approximate vector variable (fail) (libqalculate)
  • Minor bug fixes and feature enhancements

New in Qalculate! 4.3.0 (Aug 31, 2022)

  • Replace selection (instead of wrap in parentheses) on operator input if selection ends with operator
  • Act as if two arguments are required when applying base-N logarithm to expression
  • When applying function to expression, exclude to/where expression and place cursor before closing parenthesis if operator is last in selection
  • var=a syntax for variable assignment with calculated expression
  • Fix handling of Unicode powers for units in denominator, with adaptive parsing enabled (e.g. parse 10m/s² the same as 10m/s^2) (libqalculate)
  • Fix "+" ignored after "E" in number bases where "E" is a digit (libqalculate)
  • Fix scientific E notation with sign in argument when function is used without parentheses (libqalculate)
  • Fix lambertw() for values very close to zero (libqalculate)
  • Fix a*b^x+cx=d when a and c have different signs, and d is non-zero (libqalculate)
  • Fix a^x*b^x=c when a and b is negative, and c is positive (libqalculate)
  • _ Fix segfaults in some corner cases (libqalculate)
  • Fix potential issues in handling of leap seconds (e.g. during subtraction of seconds from date) (libqalculate)
  • Replace ounce with fluid ounce during conversion to volume unit (libqalculate)
  • Solve a^x+b^x+...=c in more cases (libqalculate)
  • Improve remainder/modulus for numerators with large exponents (libqalculate)
  • Truncate number in output of parsed expression and end with ellipsis if unable to display all decimals (libqalculate)
  • Improved floating point calculation and output speed, particularly for simple expressions with very high precision (libqalculate)
  • New functions: clip(), qFormat(), qError() (libqalculate)
  • Minor bug fixes and feature enhancements