initial

author: Perberos <[email protected]> 2011-11-08 13:50:37 -0300
committer: Perberos <[email protected]> 2011-11-08 13:50:37 -0300
commit: 2358ba4314dc6d757049bc4871ecf2922614b61b (patch)
tree: 12e52f491560916f0458c87b2d98ffa94500cb0f /src
download: mate-calc-2358ba4314dc6d757049bc4871ecf2922614b61b.tar.bz2
mate-calc-2358ba4314dc6d757049bc4871ecf2922614b61b.tar.xz
32 files changed, 12520 insertions, 0 deletions
diff --git a/src/Makefile.am b/src/Makefile.am
new file mode 100644
index 0000000..ce63954
--- /dev/null
+++ b/src/Makefile.am
@@ -0,0 +1,99 @@
+bin_PROGRAMS = gcalctool gcalccmd
+
+INCLUDES = \
+ -DUI_DIR=\""$(datadir)/gcalctool"\" \
+ -DVERSION=\""$(VERSION)"\" \
+ -DLOCALE_DIR=\""$(localedir)"\" \
+ -DGETTEXT_PACKAGE=\"$(GETTEXT_PACKAGE)\" \
+ $(WARN_CFLAGS) \
+ $(GCALCTOOL_CFLAGS)
+
+gcalctool_SOURCES = \
+ currency.c \
+ currency.h \
+ gcalctool.c \
+ math-buttons.c \
+ math-buttons.h \
+ math-display.c \
+ math-display.h \
+ math-equation.c \
+ math-equation.h \
+ math-preferences.c \
+ math-preferences.h \
+ math-variables.c \
+ math-variables.h \
+ math-window.c \
+ math-window.h \
+ mp.c \
+ mp.h \
+ mp-binary.c \
+ mp-convert.c \
+ mp-private.h \
+ mp-trigonometric.c \
+ mp-equation.c \
+ mp-equation.h \
+ mp-equation-private.h \
+ mp-equation-lexer.c \
+ mp-equation-lexer.h \
+ mp-equation-parser.c \
+ mp-equation-parser.h \
+ financial.c \
+ financial.h \
+ unittest.c \
+ unittest.h
+
+gcalctool_LDADD = \
+ $(GCALCTOOL_LIBS)
+
+gcalccmd_SOURCES = \
+ gcalccmd.c \
+ mp.c \
+ mp-convert.c \
+ mp-binary.c \
+ mp-trigonometric.c \
+ mp-equation.c \
+ mp-equation-parser.c \
+ mp-equation-lexer.c
+
+gcalccmd_LDADD = \
+ $(GCALCCMD_LIBS) \
+ -lm
+
+CLEANFILES = \
+ mp-equation-parser.h \
+ mp-equation-parser.c \
+ mp-equation-lexer.c \
+ mp-equation-lexer.h
+
+# Generate parser files
+mp-equation-parser.c mp-equation-parser.h: mp-equation-parser.y mp-equation-lexer.h
+ $(AM_V_GEN)$(YACC) -d -o mp-equation-parser.c $(srcdir)/mp-equation-parser.y
+
+# Generate lexer files
+mp-equation-lexer.c mp-equation-lexer.h: mp-equation-lexer.l
+ $(AM_V_GEN)$(LEX) $(srcdir)/mp-equation-lexer.l
+
+# Rebuild parser when source files change
+mp-equation-parser.o: mp-equation-lexer.h
+mp-equation-lexer.o: mp-equation-parser.h
+mp-equation.c: mp-equation-lexer.h mp-equation-parser.h
+
+# Install a symlink between gcalctool and mate-calculator
+install-exec-hook:
+ test -e "$(DESTDIR)$(bindir)/mate-calculator" \
+ || (cd "$(DESTDIR)$(bindir)" && ln -s gcalctool mate-calculator)
+
+# Remove the symlink between gcalctool and mate-calculator
+uninstall-local:
+ test -h "$(DESTDIR)$(bindir)/mate-calculator" \
+ && rm -f "$(DESTDIR)$(bindir)/mate-calculator"
+
+EXTRA_DIST = \
+ mp-equation-parser.y \
+ mp-equation-lexer.l
+
+DISTCLEANFILES = \
+ Makefile.in
+
+test: gcalctool
+ ./gcalctool -u
diff --git a/src/currency.c b/src/currency.c
new file mode 100644
index 0000000..1900a58
--- /dev/null
+++ b/src/currency.c
@@ -0,0 +1,244 @@
+#include <time.h>
+
+#include <glib.h>
+#include <glib/gstdio.h>
+#include <gio/gio.h>
+#include <libxml/tree.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+
+#include "currency.h"
+#include "mp.h"
+
+typedef struct {
+ char *short_name;
+ MPNumber value;
+} currency;
+
+static currency *currencies = NULL;
+static int currency_count = 0;
+
+static gboolean downloading_rates = FALSE;
+static gboolean loaded_rates = FALSE;
+
+static char*
+get_rate_filepath()
+{
+ return g_build_filename(g_get_user_cache_dir (),
+ "gcalctool",
+ "eurofxref-daily.xml",
+ NULL);
+}
+
+static int
+currency_get_index(const char *short_name)
+{
+ int i;
+ for (i = 0; i < currency_count; i++) {
+ if (!strcmp(short_name, currencies[i].short_name)) {
+ if (mp_is_negative(&currencies[i].value) ||
+ mp_is_zero(&currencies[i].value)) {
+ return -1;
+ } else {
+ return i;
+ }
+ }
+ }
+ return -1;
+}
+
+/* A file needs to be redownloaded if it doesn't exist, or every 7 days.
+ * When an error occur, it probably won't hurt to try to download again.
+ */
+static int
+currency_rates_needs_update()
+{
+ gchar *filename = get_rate_filepath ();
+ struct stat buf;
+ if (!g_file_test(filename, G_FILE_TEST_IS_REGULAR)) {
+ g_free(filename);
+ return 1;
+ }
+
+ if (g_stat(filename, &buf) == -1) {
+ g_free(filename);
+ return 1;
+ }
+ g_free(filename);
+
+ if (difftime(time(NULL), buf.st_mtime) > (60 * 60 * 24 * 7)) {
+ return 1;
+ }
+
+ return 0;
+}
+
+
+static void
+download_cb(GObject *object, GAsyncResult *result, gpointer user_data)
+{
+ GError *error = NULL;
+
+ if (g_file_copy_finish(G_FILE(object), result, &error))
+ g_debug("Rates updated");
+ else
+ g_warning("Couldn't download currency file: %s", error->message);
+ g_clear_error(&error);
+ downloading_rates = FALSE;
+}
+
+
+static void
+currency_download_rates()
+{
+ gchar *filename, *directory;
+ GFile *source, *dest;
+
+ downloading_rates = TRUE;
+ g_debug("Downloading rates...");
+
+ filename = get_rate_filepath();
+ directory = g_path_get_dirname(filename);
+ g_mkdir_with_parents(directory, 0755);
+ g_free(directory);
+
+ source = g_file_new_for_uri ("http://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml");
+ dest = g_file_new_for_path (filename);
+ g_free(filename);
+
+ g_file_copy_async (source, dest, G_FILE_COPY_OVERWRITE, G_PRIORITY_DEFAULT, NULL, NULL, NULL, download_cb, NULL);
+ g_object_unref(source);
+ g_object_unref(dest);
+}
+
+
+static void
+set_rate (xmlNodePtr node, currency *cur)
+{
+ xmlAttrPtr attribute;
+ for (attribute = node->properties; attribute; attribute = attribute->next) {
+ if (strcmp((char *)attribute->name, "currency") == 0) {
+ cur->short_name = (char *)xmlNodeGetContent((xmlNodePtr) attribute);
+ } else if (strcmp ((char *)attribute->name, "rate") == 0) {
+ char *val = (char *)xmlNodeGetContent ((xmlNodePtr) attribute);
+ mp_set_from_string(val, 10, &(cur->value));
+ xmlFree (val);
+ }
+ }
+}
+
+static void
+currency_load_rates()
+{
+ char *filename = get_rate_filepath();
+ xmlDocPtr document;
+ xmlXPathContextPtr xpath_ctx;
+ xmlXPathObjectPtr xpath_obj;
+ int i, len;
+
+ g_return_if_fail(g_file_test(filename, G_FILE_TEST_IS_REGULAR));
+
+ xmlInitParser();
+ document = xmlReadFile(filename, NULL, 0);
+ g_free (filename);
+ if (document == NULL) {
+ fprintf(stderr, "Couldn't parse data file\n");
+ return;
+ }
+
+ xpath_ctx = xmlXPathNewContext(document);
+ if (xpath_ctx == NULL) {
+ xmlFreeDoc(document);
+ fprintf(stderr, "Couldn't create XPath context\n");
+ return;
+ }
+
+ xmlXPathRegisterNs(xpath_ctx,
+ BAD_CAST("xref"),
+ BAD_CAST("http://www.ecb.int/vocabulary/2002-08-01/eurofxref"));
+ xpath_obj = xmlXPathEvalExpression(BAD_CAST("//xref:Cube[@currency][@rate]"),
+ xpath_ctx);
+
+ if (xpath_obj == NULL) {
+ xmlXPathFreeContext(xpath_ctx);
+ xmlFreeDoc(document);
+ fprintf(stderr, "Couldn't create XPath object\n");
+ return;
+ }
+
+ len = (xpath_obj->nodesetval) ? xpath_obj->nodesetval->nodeNr : 0;
+ currency_count = len + 1;
+ currencies = g_slice_alloc0(sizeof(currency) * currency_count);
+ for (i = 0; i < len; i++) {
+ if (xpath_obj->nodesetval->nodeTab[i]->type == XML_ELEMENT_NODE) {
+ set_rate(xpath_obj->nodesetval->nodeTab[i], &currencies[i]);
+ }
+
+ // Avoid accessing removed elements
+ if (xpath_obj->nodesetval->nodeTab[i]->type != XML_NAMESPACE_DECL)
+ xpath_obj->nodesetval->nodeTab[i] = NULL;
+ }
+
+ currencies[len].short_name = g_strdup("EUR");
+ MPNumber foo;
+ mp_set_from_integer(1, &foo);
+ currencies[len].value = foo;
+
+ xmlXPathFreeObject(xpath_obj);
+ xmlXPathFreeContext(xpath_ctx);
+ xmlFreeDoc(document);
+ xmlCleanupParser();
+
+ g_debug("Rates loaded");
+ loaded_rates = TRUE;
+}
+
+
+gboolean
+currency_convert(const MPNumber *from_amount,
+ const char *source_currency, const char *target_currency,
+ MPNumber *to_amount)
+{
+ int from_index, to_index;
+
+ if (downloading_rates)
+ return FALSE;
+
+ /* Update currency if necessary */
+ if (currency_rates_needs_update()) {
+ currency_download_rates();
+ return FALSE;
+ }
+ if (!loaded_rates)
+ currency_load_rates();
+ 
+ from_index = currency_get_index(source_currency);
+ to_index = currency_get_index(target_currency);
+ if (from_index < 0 || to_index < 0)
+ return FALSE;
+
+ if (mp_is_zero(&currencies[from_index].value) ||
+ mp_is_zero(&currencies[to_index].value)) {
+ mp_set_from_integer(0, to_amount);
+ return FALSE;
+ }
+
+ mp_divide(from_amount, &currencies[from_index].value, to_amount);
+ mp_multiply(to_amount, &currencies[to_index].value, to_amount);
+
+ return TRUE;
+}
+
+void
+currency_free_resources()
+{
+ int i;
+
+ for (i = 0; i < currency_count; i++) {
+ if (currencies[i].short_name != NULL)
+ xmlFree(currencies[i].short_name);
+ }
+ g_slice_free1(currency_count * sizeof(currency), currencies);
+ currencies = NULL;
+ currency_count = 0;
+}
diff --git a/src/currency.h b/src/currency.h
new file mode 100644
index 0000000..02cbfd8
--- /dev/null
+++ b/src/currency.h
@@ -0,0 +1,67 @@
+#ifndef CURRENCY_H
+#define CURRENCY_H
+
+#include <glib/gi18n.h>
+
+#include "mp.h"
+
+struct currency_name {
+ char *short_name;
+ char *symbol;
+ char *long_name;
+};
+
+/*
+ * List taken from http://www.ecb.int/press/pr/date/2008/html/pr081205.en.html
+ * with euro added.
+ */
+static const struct currency_name currency_names[] = {
+ {"AUD", "$", N_("Australian dollar")},
+ {"BGN", "лв", N_("Bulgarian lev")},
+ {"BRL", "R$", N_("Brazilian real")},
+ {"CAD", "$", N_("Canadian dollar")},
+ {"CHF", "Fr", N_("Swiss franc")},
+ {"CNY", "元", N_("Chinese yuan renminbi")},
+ {"CZK", "Kč", N_("Czech koruna")},
+ {"DKK", "kr", N_("Danish krone")},
+ {"EEK", "KR", N_("Estonian kroon")},
+ {"EUR", "€", N_("Euro")},
+ {"GBP", "£", N_("Pound sterling")},
+ {"HKD", "$", N_("Hong Kong dollar")},
+ {"HRK", "kn", N_("Croatian kuna")},
+ {"HUF", "Ft", N_("Hungarian forint")},
+ {"IDR", "Rp", N_("Indonesian rupiah")},
+ {"INR", "Rs", N_("Indian rupee")},
+ {"ISK", "kr", N_("Icelandic krona")},
+ {"JPY", "¥", N_("Japanese yen")},
+ {"KRW", "₩", N_("South Korean won")},
+ {"LTL", "Lt", N_("Lithuanian litas")},
+ {"LVL", "Ls", N_("Latvian lats")},
+ {"MXN", "$", N_("Mexican peso")},
+ {"MYR", "RM", N_("Malaysian ringgit")},
+ {"NOK", "kr", N_("Norwegian krone")},
+ {"NZD", "$", N_("New Zealand dollar")},
+ {"PHP", "₱", N_("Philippine peso")},
+ {"PLN", "zł", N_("Polish zloty")},
+ {"RON", "L", N_("New Romanian leu")},
+ {"RUB", "руб.", N_("Russian rouble")},
+ {"SEK", "kr", N_("Swedish krona")},
+ {"SGD", "$", N_("Singapore dollar")},
+ {"THB", "฿", N_("Thai baht")},
+ {"TRY", "TL", N_("New Turkish lira")},
+ {"USD", "$", N_("US dollar")},
+ {"ZAR", "R", N_("South African rand")},
+ {NULL, NULL}
+};
+
+// FIXME: Should indicate when rates are updated to UI
+
+/* Converts an amount of money from one currency to another */
+gboolean currency_convert(const MPNumber *from_amount,
+ const char *source_currency, const char *target_currency,
+ MPNumber *to_amount);
+
+/* Frees up all allocated resources */
+void currency_free_resources(void);
+
+#endif /* CURRENCY_H */
diff --git a/src/financial.c b/src/financial.c
new file mode 100644
index 0000000..94a21c0
--- /dev/null
+++ b/src/financial.c
@@ -0,0 +1,294 @@
+/* Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <glib/gi18n.h>
+
+#include "financial.h"
+#include "mp.h"
+
+static void
+calc_ctrm(MathEquation *equation, MPNumber *t, MPNumber *pint, MPNumber *fv, MPNumber *pv)
+{
+
+/* Cterm - pint (periodic interest rate).
+ * fv (future value).
+ * pv (present value).
+ *
+ * RESULT = log(fv / pv) / log(1 + pint)
+ */
+ MPNumber MP1, MP2, MP3, MP4;
+
+ mp_divide(fv, pv, &MP1);
+ mp_ln(&MP1, &MP2);
+ mp_add_integer(pint, 1, &MP3);
+ mp_ln(&MP3, &MP4);
+ mp_divide(&MP2, &MP4, t);
+}
+
+
+static void
+calc_ddb(MathEquation *equation, MPNumber *t, MPNumber *cost, MPNumber *life, MPNumber *period)
+{
+
+/* Ddb - cost (amount paid for asset).
+ * life (useful life of the asset).
+ * period (time period for depreciation allowance).
+ *
+ * bv = 0.0;
+ * for (i = 0; i < life; i++)
+ * {
+ * VAL = ((cost - bv) * 2) / life
+ * bv += VAL
+ * }
+ * RESULT = VAL
+ *
+ */
+
+ int i;
+ int len;
+ MPNumber MPbv, MP1, MP2;
+
+ mp_set_from_integer(0, &MPbv);
+ len = mp_cast_to_int(period);
+ for (i = 0; i < len; i++) {
+ mp_subtract(cost, &MPbv, &MP1);
+ mp_multiply_integer(&MP1, 2, &MP2);
+ mp_divide(&MP2, life, t);
+ mp_set_from_mp(&MPbv, &MP1);
+ mp_add(&MP1, t, &MPbv); /* TODO: why result is MPbv, for next loop? */
+ }
+
+ if (len >= 0) {
+ math_equation_set_status (equation, ("Error: the number of periods must be positive"));
+ mp_set_from_integer(0, t);
+ }
+}
+
+
+static void
+calc_fv(MathEquation *equation, MPNumber *t, MPNumber *pmt, MPNumber *pint, MPNumber *n)
+{
+
+/* Fv - pmt (periodic payment).
+ * pint (periodic interest rate).
+ * n (number of periods).
+ *
+ * RESULT = pmt * (pow(1 + pint, n) - 1) / pint
+ */
+
+ MPNumber MP1, MP2, MP3, MP4;
+
+ mp_add_integer(pint, 1, &MP1);
+ mp_xpowy(&MP1, n, &MP2);
+ mp_add_integer(&MP2, -1, &MP3);
+ mp_multiply(pmt, &MP3, &MP4);
+ mp_divide(&MP4, pint, t);
+}
+
+
+static void
+calc_gpm(MathEquation *equation, MPNumber *t, MPNumber *cost, MPNumber *margin)
+{
+
+/* Gpm - cost (cost of sale).
+ * margin (gross profit margin.
+ *
+ * RESULT = cost / (1 - margin)
+ */
+
+ MPNumber MP1, MP2;
+
+ mp_set_from_integer(1, &MP1);
+ mp_subtract(&MP1, margin, &MP2);
+ mp_divide(cost, &MP2, t);
+}
+
+
+static void
+calc_pmt(MathEquation *equation, MPNumber *t, MPNumber *prin, MPNumber *pint, MPNumber *n)
+{
+
+/* Pmt - prin (principal).
+ * pint (periodic interest rate).
+ * n (term).
+ *
+ * RESULT = prin * (pint / (1 - pow(pint + 1, -1 * n)))
+ */
+
+ MPNumber MP1, MP2, MP3, MP4;
+
+ mp_add_integer(pint, 1, &MP1);
+ mp_multiply_integer(n, -1, &MP2);
+ mp_xpowy(&MP1, &MP2, &MP3);
+ mp_multiply_integer(&MP3, -1, &MP4);
+ mp_add_integer(&MP4, 1, &MP1);
+ mp_divide(pint, &MP1, &MP2);
+ mp_multiply(prin, &MP2, t);
+}
+
+
+static void
+calc_pv(MathEquation *equation, MPNumber *t, MPNumber *pmt, MPNumber *pint, MPNumber *n)
+{
+
+/* Pv - pmt (periodic payment).
+ * pint (periodic interest rate).
+ * n (term).
+ *
+ * RESULT = pmt * (1 - pow(1 + pint, -1 * n)) / pint
+ */
+
+ MPNumber MP1, MP2, MP3, MP4;
+
+ mp_add_integer(pint, 1, &MP1);
+ mp_multiply_integer(n, -1, &MP2);
+ mp_xpowy(&MP1, &MP2, &MP3);
+ mp_multiply_integer(&MP3, -1, &MP4);
+ mp_add_integer(&MP4, 1, &MP1);
+ mp_divide(&MP1, pint, &MP2);
+ mp_multiply(pmt, &MP2, t);
+}
+
+
+static void
+calc_rate(MathEquation *equation, MPNumber *t, MPNumber *fv, MPNumber *pv, MPNumber *n)
+{
+
+/* Rate - fv (future value).
+ * pv (present value).
+ * n (term).
+ *
+ * RESULT = pow(fv / pv, 1 / n) - 1
+ */
+
+ MPNumber MP1, MP2, MP3, MP4;
+
+ mp_divide(fv, pv, &MP1);
+ mp_set_from_integer(1, &MP2);
+ mp_divide(&MP2, n, &MP3);
+ mp_xpowy(&MP1, &MP3, &MP4);
+ mp_add_integer(&MP4, -1, t);
+}
+
+
+static void
+calc_sln(MathEquation *equation, MPNumber *t, MPNumber *cost, MPNumber *salvage, MPNumber *life)
+{
+
+/* Sln - cost (cost of the asset).
+ * salvage (salvage value of the asset).
+ * life (useful life of the asset).
+ *
+ * RESULT = (cost - salvage) / life
+ */
+
+ MPNumber MP1;
+ mp_subtract(cost, salvage, &MP1);
+ mp_divide(&MP1, life, t);
+}
+
+
+static void
+calc_syd(MathEquation *equation, MPNumber *t, MPNumber *cost, MPNumber *salvage, MPNumber *life, MPNumber *period)
+{
+
+/* Syd - cost (cost of the asset).
+ * salvage (salvage value of the asset).
+ * life (useful life of the asset).
+ * period (period for which depreciation is computed).
+ *
+ * RESULT = (cost - salvage) * (life - period + 1) /
+ * (life * (life + 1)) / 2
+ */
+
+ MPNumber MP1, MP2, MP3, MP4;
+
+ mp_subtract(life, period, &MP2);
+ mp_add_integer(&MP2, 1, &MP3);
+ mp_add_integer(life, 1, &MP2);
+ mp_multiply(life, &MP2, &MP4);
+ mp_set_from_integer(2, &MP2);
+ mp_divide(&MP4, &MP2, &MP1);
+ mp_divide(&MP3, &MP1, &MP2);
+ mp_subtract(cost, salvage, &MP1);
+ mp_multiply(&MP1, &MP2, t);
+}
+
+
+static void
+calc_term(MathEquation *equation, MPNumber *t, MPNumber *pmt, MPNumber *fv, MPNumber *pint)
+{
+
+/* Term - pmt (periodic payment).
+ * fv (future value).
+ * pint (periodic interest rate).
+ *
+ * RESULT = log(1 + (fv * pint / pmt)) / log(1 + pint)
+ */
+
+ MPNumber MP1, MP2, MP3, MP4;
+
+ mp_add_integer(pint, 1, &MP1);
+ mp_ln(&MP1, &MP2);
+ mp_multiply(fv, pint, &MP1);
+ mp_divide(&MP1, pmt, &MP3);
+ mp_add_integer(&MP3, 1, &MP4);
+ mp_ln(&MP4, &MP1);
+ mp_divide(&MP1, &MP2, t);
+}
+
+
+void
+do_finc_expression(MathEquation *equation, int function, MPNumber *arg1, MPNumber *arg2, MPNumber *arg3, MPNumber *arg4)
+{
+ MPNumber result;
+ switch (function) {
+ case FINC_CTRM_DIALOG:
+ calc_ctrm(equation, &result, arg1, arg2, arg3);
+ break;
+ case FINC_DDB_DIALOG:
+ calc_ddb(equation, &result, arg1, arg2, arg3);
+ break;
+ case FINC_FV_DIALOG:
+ calc_fv(equation, &result, arg1, arg2, arg3);
+ break;
+ case FINC_GPM_DIALOG:
+ calc_gpm(equation, &result, arg1, arg2);
+ break;
+ case FINC_PMT_DIALOG:
+ calc_pmt(equation, &result, arg1, arg2, arg3);
+ break;
+ case FINC_PV_DIALOG:
+ calc_pv(equation, &result, arg1, arg2, arg3);
+ break;
+ case FINC_RATE_DIALOG:
+ calc_rate(equation, &result, arg1, arg2, arg3);
+ break;
+ case FINC_SLN_DIALOG:
+ calc_sln(equation, &result, arg1, arg2, arg3);
+ break;
+ case FINC_SYD_DIALOG:
+ calc_syd(equation, &result, arg1, arg2, arg3, arg4);
+ break;
+ case FINC_TERM_DIALOG:
+ calc_term(equation, &result, arg1, arg2, arg3);
+ break;
+ }
+ math_equation_set_number(equation, &result);
+}
diff --git a/src/financial.h b/src/financial.h
new file mode 100644
index 0000000..6aa8f3c
--- /dev/null
+++ b/src/financial.h
@@ -0,0 +1,41 @@
+/* Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef FINANCIAL_H
+#define FINANCIAL_H
+
+#include "mp.h"
+#include "math-equation.h"
+
+void do_finc_expression(MathEquation *equation, int function, MPNumber *arg1, MPNumber *arg2, MPNumber *arg3, MPNumber *arg4);
+
+enum finc_dialogs {
+ FINC_CTRM_DIALOG,
+ FINC_DDB_DIALOG,
+ FINC_FV_DIALOG,
+ FINC_GPM_DIALOG,
+ FINC_PMT_DIALOG,
+ FINC_PV_DIALOG,
+ FINC_RATE_DIALOG,
+ FINC_SLN_DIALOG,
+ FINC_SYD_DIALOG,
+ FINC_TERM_DIALOG
+};
+
+#endif /* FINANCIAL_H */
diff --git a/src/gcalccmd.c b/src/gcalccmd.c
new file mode 100644
index 0000000..9af9a58
--- /dev/null
+++ b/src/gcalccmd.c
@@ -0,0 +1,98 @@
+/* $Header$
+ *
+ * Copyright (c) 2009 Rich Burridge
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but 
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <time.h>
+
+#include "mp-equation.h"
+
+#define MAXLINE 1024
+
+static void
+solve(const char *equation)
+{
+ int ret;
+ MPEquationOptions options;
+ MPNumber z;
+ char result_str[MAXLINE];
+ 
+ memset(&options, 0, sizeof(options));
+ options.base = 10;
+ options.wordlen = 32;
+ options.angle_units = MP_DEGREES;
+ 
+ ret = mp_equation_parse(equation, &options, &z, NULL);
+
+ if (ret == PARSER_ERR_MP)
+ fprintf(stderr, "Error %s\n", mp_get_error());
+ else if (ret) 
+ fprintf(stderr, "Error %d\n", ret);
+ else {
+ mp_cast_to_string(&z, 10, 10, 9, 1, result_str, MAXLINE);
+ printf("%s\n", result_str);
+ }
+}
+
+
+/* Adjust user input equation string before solving it. */
+static void
+str_adjust(char *str)
+{
+ int i, j = 0;
+
+ str[strlen(str)-1] = '\0'; /* Remove newline at end of string. */
+ for (i = 0; str[i] != '\0'; i++) { /* Remove whitespace. */
+ if (str[i] != ' ' && str[i] != '\t')
+ str[j++] = str[i];
+ }
+ str[j] = '\0';
+ if (j > 0 && str[j-1] == '=') /* Remove trailing '=' (if present). */
+ str[j-1] = '\0';
+}
+
+int
+main(int argc, char **argv)
+{
+ char *equation, *line;
+ size_t nbytes = MAXLINE;
+
+ /* Seed random number generator. */
+ srand48((long) time((time_t *) 0));
+
+ equation = (char *) malloc(MAXLINE * sizeof(char));
+ while (1) {
+ printf("> ");
+ line = fgets(equation, nbytes, stdin);
+
+ if (line != NULL)
+ str_adjust(equation);
+
+ if (line == NULL || strcmp(equation, "exit") == 0 || strcmp(equation, "quit") == 0 || strlen(equation) == 0)
+ break;
+
+ solve(equation);
+ }
+ free(equation);
+
+ return 0;
+}
diff --git a/src/gcalctool.c b/src/gcalctool.c
new file mode 100644
index 0000000..4e40f6a
--- /dev/null
+++ b/src/gcalctool.c
@@ -0,0 +1,260 @@
+/* Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "currency.h"
+#include "unittest.h"
+#include "math-window.h"
+#include "mp-equation.h"
+
+static GSettings *settings = NULL;
+
+static MathWindow *window;
+
+static void
+version(const gchar *progname)
+{
+ /* NOTE: Is not translated so can be easily parsed */
+ fprintf(stderr, "%1$s %2$s\n", progname, VERSION);
+}
+
+
+static void
+solve(const char *equation)
+{
+ MPEquationOptions options;
+ MPErrorCode error;
+ MPNumber result;
+ char result_str[1024];
+
+ memset(&options, 0, sizeof(options));
+ options.base = 10;
+ options.wordlen = 32;
+ options.angle_units = MP_DEGREES;
+
+ error = mp_equation_parse(equation, &options, &result, NULL);
+ if(error == PARSER_ERR_MP) {
+ fprintf(stderr, "Error: %s\n", mp_get_error());
+ exit(1);
+ }
+ else if(error != 0) {
+ fprintf(stderr, "Error: %s\n", mp_error_code_to_string(error));
+ exit(1);
+ }
+ else {
+ mp_cast_to_string(&result, 10, 10, 9, 1, result_str, 1024);
+ printf("%s\n", result_str);
+ exit(0);
+ }
+}
+
+
+static void
+usage(const gchar *progname, gboolean show_application, gboolean show_gtk)
+{
+ fprintf(stderr,
+ /* Description on how to use gcalctool displayed on command-line */
+ _("Usage:\n"
+ " %s — Perform mathematical calculations"), progname);
+
+ fprintf(stderr,
+ "\n\n");
+
+ fprintf(stderr,
+ /* Description on gcalctool command-line help options displayed on command-line */
+ _("Help Options:\n"
+ " -v, --version Show release version\n"
+ " -h, -?, --help Show help options\n"
+ " --help-all Show all help options\n"
+ " --help-gtk Show GTK+ options"));
+ fprintf(stderr,
+ "\n\n");
+
+ if (show_gtk) {
+ fprintf(stderr,
+ /* Description on gcalctool command-line GTK+ options displayed on command-line */
+ _("GTK+ Options:\n"
+ " --class=CLASS Program class as used by the window manager\n"
+ " --name=NAME Program name as used by the window manager\n"
+ " --screen=SCREEN X screen to use\n"
+ " --sync Make X calls synchronous\n"
+ " --gtk-module=MODULES Load additional GTK+ modules\n"
+ " --g-fatal-warnings Make all warnings fatal"));
+ fprintf(stderr,
+ "\n\n");
+ }
+
+ if (show_application) {
+ fprintf(stderr,
+ /* Description on gcalctool application options displayed on command-line */
+ _("Application Options:\n"
+ " -u, --unittest Perform unit tests\n"
+ " -s, --solve <equation> Solve the given equation"));
+ fprintf(stderr,
+ "\n\n");
+ }
+}
+
+
+static void
+get_options(int argc, char *argv[])
+{
+ int i;
+ char *progname, *arg;
+
+ progname = g_path_get_basename(argv[0]);
+
+ for (i = 1; i < argc; i++) {
+ arg = argv[i];
+
+ if (strcmp(arg, "-v") == 0 ||
+ strcmp(arg, "--version") == 0) {
+ version(progname);
+ exit(0);
+ }
+ else if (strcmp(arg, "-h") == 0 ||
+ strcmp(arg, "-?") == 0 ||
+ strcmp(arg, "--help") == 0) {
+ usage(progname, TRUE, FALSE);
+ exit(0);
+ }
+ else if (strcmp(arg, "--help-all") == 0) {
+ usage(progname, TRUE, TRUE);
+ exit(0);
+ }
+ else if (strcmp(arg, "--help-gtk") == 0) {
+ usage(progname, FALSE, TRUE);
+ exit(0);
+ }
+ else if (strcmp(arg, "-s") == 0 ||
+ strcmp(arg, "--solve") == 0) {
+ i++;
+ if (i >= argc) {
+ fprintf(stderr,
+ /* Error printed to stderr when user uses --solve argument without an equation */
+ _("Argument --solve requires an equation to solve"));
+ fprintf(stderr, "\n");
+ exit(1);
+ }
+ else
+ solve(argv[i]);
+ }
+ else if (strcmp(arg, "-u") == 0 ||
+ strcmp(arg, "--unittest") == 0) {
+ unittest();
+ }
+ else {
+ fprintf(stderr,
+ /* Error printed to stderr when user provides an unknown command-line argument */
+ _("Unknown argument '%s'"), arg);
+ fprintf(stderr, "\n");
+ usage(progname, TRUE, FALSE);
+ exit(1);
+ }
+ }
+}
+
+
+static void
+quit_cb(MathWindow *window)
+{
+ MathEquation *equation;
+ MathButtons *buttons;
+
+ equation = math_window_get_equation(window);
+ buttons = math_window_get_buttons(window);
+
+ g_settings_set_int(settings, "accuracy", math_equation_get_accuracy(equation));
+ g_settings_set_int(settings, "word-size", math_equation_get_word_size(equation));
+ g_settings_set_int(settings, "base", math_buttons_get_programming_base(buttons));
+ g_settings_set_boolean(settings, "show-thousands", math_equation_get_show_thousands_separators(equation));
+ g_settings_set_boolean(settings, "show-zeroes", math_equation_get_show_trailing_zeroes(equation));
+ g_settings_set_enum(settings, "number-format", math_equation_get_number_format(equation));
+ g_settings_set_enum(settings, "angle-units", math_equation_get_angle_units(equation));
+ g_settings_set_enum(settings, "button-mode", math_buttons_get_mode(buttons));
+ g_settings_set_string(settings, "source-currency", math_equation_get_source_currency(equation));
+ g_settings_set_string(settings, "target-currency", math_equation_get_target_currency(equation));
+ g_settings_sync();
+
+ currency_free_resources();
+ gtk_main_quit();
+}
+
+
+int
+main(int argc, char **argv)
+{
+ MathEquation *equation;
+ int accuracy = 9, word_size = 64, base = 10;
+ gboolean show_tsep = FALSE, show_zeroes = FALSE;
+ DisplayFormat number_format;
+ MPAngleUnit angle_units;
+ ButtonMode button_mode;
+ gchar *source_currency, *target_currency;
+
+ g_type_init();
+
+ bindtextdomain(GETTEXT_PACKAGE, LOCALE_DIR);
+ bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
+ textdomain(GETTEXT_PACKAGE);
+
+ /* Seed random number generator. */
+ srand48((long) time((time_t *) 0));
+
+ get_options(argc, argv);
+
+ settings = g_settings_new ("org.mate.gcalctool");
+ accuracy = g_settings_get_int(settings, "accuracy");
+ word_size = g_settings_get_int(settings, "word-size");
+ base = g_settings_get_int(settings, "base");
+ show_tsep = g_settings_get_boolean(settings, "show-thousands");
+ show_zeroes = g_settings_get_boolean(settings, "show-zeroes");
+ number_format = g_settings_get_enum(settings, "number-format");
+ angle_units = g_settings_get_enum(settings, "angle-units");
+ button_mode = g_settings_get_enum(settings, "button-mode");
+ source_currency = g_settings_get_string(settings, "source-currency");
+ target_currency = g_settings_get_string(settings, "target-currency");
+
+ equation = math_equation_new();
+ math_equation_set_accuracy(equation, accuracy);
+ math_equation_set_word_size(equation, word_size);
+ math_equation_set_show_thousands_separators(equation, show_tsep);
+ math_equation_set_show_trailing_zeroes(equation, show_zeroes);
+ math_equation_set_number_format(equation, number_format);
+ math_equation_set_angle_units(equation, angle_units);
+ math_equation_set_source_currency(equation, source_currency);
+ math_equation_set_target_currency(equation, target_currency);
+ g_free(source_currency);
+ g_free(target_currency);
+
+ gtk_init(&argc, &argv);
+
+ window = math_window_new(equation);
+ g_signal_connect(G_OBJECT(window), "quit", G_CALLBACK(quit_cb), NULL);
+ math_buttons_set_programming_base(math_window_get_buttons(window), base);
+ math_buttons_set_mode(math_window_get_buttons(window), button_mode); // FIXME: We load the basic buttons even if we immediately switch to the next type
+
+ gtk_widget_show(GTK_WIDGET(window));
+ gtk_main();
+
+ return(0);
+}
diff --git a/src/math-buttons.c b/src/math-buttons.c
new file mode 100644
index 0000000..01abb1e
--- /dev/null
+++ b/src/math-buttons.c
@@ -0,0 +1,1790 @@
+/* Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <glib/gi18n.h>
+
+#include "math-buttons.h"
+#include "financial.h"
+#include "currency.h"
+
+enum {
+ PROP_0,
+ PROP_EQUATION,
+ PROP_MODE
+};
+
+static GType button_mode_type;
+
+#define MAXBITS 64 /* Bit panel: number of bit fields. */
+
+struct MathButtonsPrivate
+{
+ MathEquation *equation;
+
+ ButtonMode mode;
+ gint programming_base;
+ 
+ GtkBuilder *basic_ui, *advanced_ui, *financial_ui, *programming_ui;
+
+ GdkColor color_numbers, color_action, color_operator, color_function, color_memory, color_group;
+
+ GtkWidget *bas_panel, *adv_panel, *fin_panel, *prog_panel;
+ GtkWidget *active_panel;
+
+ GtkWidget *shift_left_menu, *shift_right_menu;
+
+ GtkWidget *function_menu;
+
+ GList *superscript_toggles;
+ GList *subscript_toggles;
+
+ GtkWidget *angle_combo;
+ GtkWidget *angle_label;
+ 
+ GtkWidget *base_combo; 
+ GtkWidget *base_label;
+ GtkWidget *bit_panel;
+ GtkWidget *bit_labels[MAXBITS];
+
+ GtkWidget *source_currency_combo;
+ GtkWidget *target_currency_combo;
+ GtkWidget *currency_label;
+
+ GtkWidget *character_code_dialog;
+ GtkWidget *character_code_entry;
+};
+
+G_DEFINE_TYPE (MathButtons, math_buttons, GTK_TYPE_VBOX);
+
+#define UI_BASIC_FILE UI_DIR "/buttons-basic.ui"
+#define UI_ADVANCED_FILE UI_DIR "/buttons-advanced.ui"
+#define UI_FINANCIAL_FILE UI_DIR "/buttons-financial.ui"
+#define UI_PROGRAMMING_FILE UI_DIR "/buttons-programming.ui"
+
+#define GET_WIDGET(ui, name) \
+ GTK_WIDGET(gtk_builder_get_object((ui), (name)))
+
+#define WM_WIDTH_FACTOR 10
+#define WM_HEIGHT_FACTOR 30
+
+typedef enum
+{
+ NUMBER,
+ NUMBER_BOLD,
+ OPERATOR,
+ FUNCTION,
+ MEMORY,
+ GROUP,
+ ACTION
+} ButtonClass;
+
+typedef struct {
+ const char *widget_name;
+ const char *data;
+ ButtonClass class;
+ const char *tooltip;
+} ButtonData;
+
+static ButtonData button_data[] = {
+ {"pi", "π", NUMBER,
+ /* Tooltip for the Pi button */
+ N_("Pi [Ctrl+P]")},
+ {"eulers_number", "e", NUMBER,
+ /* Tooltip for the Euler's Number button */
+ N_("Euler’s Number")},
+ {"imaginary", "i", NUMBER, NULL},
+ {"numeric_point", NULL, NUMBER, NULL},
+ {"subscript", NULL, NUMBER_BOLD,
+ /* Tooltip for the subscript button */
+ N_("Subscript mode [Alt]")},
+ {"superscript", NULL, NUMBER_BOLD,
+ /* Tooltip for the superscript button */
+ N_("Superscript mode [Ctrl]")},
+ {"exponential", NULL, NUMBER_BOLD,
+ /* Tooltip for the scientific exponent button */
+ N_("Scientific exponent [Ctrl+E]")},
+ {"add", "+", OPERATOR,
+ /* Tooltip for the add button */
+ N_("Add [+]")},
+ {"subtract", "−", OPERATOR,
+ /* Tooltip for the subtract button */
+ N_("Subtract [-]")},
+ {"multiply", "×", OPERATOR,
+ /* Tooltip for the multiply button */
+ N_("Multiply [*]")},
+ {"divide", "÷", OPERATOR,
+ /* Tooltip for the divide button */
+ N_("Divide [/]")},
+ {"modulus_divide", " mod ", OPERATOR,
+ /* Tooltip for the modulus divide button */
+ N_("Modulus divide")},
+ {"function", NULL, FUNCTION,
+ /* Tooltip for the additional functions button */
+ N_("Additional Functions")},
+ {"x_pow_y", "^", FUNCTION,
+ /* Tooltip for the exponent button */
+ N_("Exponent [^ or **]")},
+ {"x_squared", "²", FUNCTION,
+ /* Tooltip for the square button */
+ N_("Square [Ctrl+2]")},
+ {"percentage", "%", NUMBER,
+ /* Tooltip for the percentage button */
+ N_("Percentage [%]")},
+ {"factorial", "!", FUNCTION,
+ /* Tooltip for the factorial button */
+ N_("Factorial [!]")},
+ {"abs", "|", FUNCTION,
+ /* Tooltip for the absolute value button */
+ N_("Absolute value [|]")},
+ {"arg", "Arg ", FUNCTION,
+ /* Tooltip for the complex argument component button */
+ N_("Complex argument")},
+ {"conjugate", "conj ", FUNCTION,
+ /* Tooltip for the complex conjugate button */
+ N_("Complex conjugate")},
+ {"root", "√", FUNCTION,
+ /* Tooltip for the root button */
+ N_("Root [Ctrl+R]")},
+ {"square_root", "√", FUNCTION,
+ /* Tooltip for the square root button */
+ N_("Square root [Ctrl+R]")},
+ {"logarithm", "log ", FUNCTION,
+ /* Tooltip for the logarithm button */
+ N_("Logarithm")},
+ {"natural_logarithm", "ln ", FUNCTION,
+ /* Tooltip for the natural logarithm button */
+ N_("Natural Logarithm")},
+ {"sine", "sin ", FUNCTION,
+ /* Tooltip for the sine button */
+ N_("Sine")},
+ {"cosine", "cos ", FUNCTION,
+ /* Tooltip for the cosine button */
+ N_("Cosine")},
+ {"tangent", "tan ", FUNCTION,
+ /* Tooltip for the tangent button */
+ N_("Tangent")},
+ {"hyperbolic_sine", "sinh ", FUNCTION,
+ /* Tooltip for the hyperbolic sine button */
+ N_("Hyperbolic Sine")},
+ {"hyperbolic_cosine", "cosh ", FUNCTION,
+ /* Tooltip for the hyperbolic cosine button */
+ N_("Hyperbolic Cosine")},
+ {"hyperbolic_tangent", "tanh ", FUNCTION,
+ /* Tooltip for the hyperbolic tangent button */
+ N_("Hyperbolic Tangent")},
+ {"inverse", "⁻¹", FUNCTION,
+ /* Tooltip for the inverse button */
+ N_("Inverse [Ctrl+I]")},
+ {"and", "∧", OPERATOR,
+ /* Tooltip for the boolean AND button */
+ N_("Boolean AND")},
+ {"or", "∨", OPERATOR,
+ /* Tooltip for the boolean OR button */
+ N_("Boolean OR")},
+ {"xor", "⊻", OPERATOR,
+ /* Tooltip for the exclusive OR button */
+ N_("Boolean Exclusive OR")},
+ {"not", "¬", FUNCTION,
+ /* Tooltip for the boolean NOT button */
+ N_("Boolean NOT")},
+ {"integer_portion", "int ", FUNCTION,
+ /* Tooltip for the integer component button */
+ N_("Integer Component")},
+ {"fractional_portion", "frac ", FUNCTION,
+ /* Tooltip for the fractional component button */
+ N_("Fractional Component")},
+ {"real_portion", "Re ", FUNCTION,
+ /* Tooltip for the real component button */
+ N_("Real Component")},
+ {"imaginary_portion", "Im ", FUNCTION,
+ /* Tooltip for the imaginary component button */
+ N_("Imaginary Component")},
+ {"ones_complement", "ones ", FUNCTION,
+ /* Tooltip for the ones complement button */
+ N_("Ones Complement")},
+ {"twos_complement", "twos ", FUNCTION,
+ /* Tooltip for the twos complement button */
+ N_("Twos Complement")},
+ {"trunc", "trunc ", FUNCTION,
+ /* Tooltip for the truncate button */
+ N_("Truncate")},
+ {"start_group", "(", GROUP,
+ /* Tooltip for the start group button */
+ N_("Start Group [(]")},
+ {"end_group", ")", GROUP,
+ /* Tooltip for the end group button */
+ N_("End Group [)]")},
+ {"store", NULL, MEMORY,
+ /* Tooltip for the assign variable button */
+ N_("Assign Variable")},
+ {"recall", NULL, MEMORY,
+ /* Tooltip for the insert variable button */
+ N_("Insert Variable")},
+ {"character", NULL, MEMORY,
+ /* Tooltip for the insert character code button */
+ N_("Insert Character Code")},
+ {"result", NULL, ACTION,
+ /* Tooltip for the solve button */
+ N_("Calculate Result")},
+ {"factor", NULL, ACTION,
+ /* Tooltip for the factor button */
+ N_("Factorize [Ctrl+F]")},
+ {"clear", NULL, GROUP,
+ /* Tooltip for the clear button */
+ N_("Clear Display [Escape]")},
+ {"undo", NULL, GROUP,
+ /* Tooltip for the undo button */
+ N_("Undo [Ctrl+Z]")},
+ {"shift_left", NULL, ACTION,
+ /* Tooltip for the shift left button */
+ N_("Shift Left")}, 
+ {"shift_right", NULL, ACTION,
+ /* Tooltip for the shift right button */
+ N_("Shift Right")}, 
+ {"finc_compounding_term", NULL, FUNCTION,
+ /* Tooltip for the compounding term button */
+ N_("Compounding Term")},
+ {"finc_double_declining_depreciation", NULL, FUNCTION,
+ /* Tooltip for the double declining depreciation button */
+ N_("Double Declining Depreciation")},
+ {"finc_future_value", NULL, FUNCTION,
+ /* Tooltip for the future value button */
+ N_("Future Value")},
+ {"finc_term", NULL, FUNCTION,
+ /* Tooltip for the financial term button */
+ N_("Financial Term")},
+ {"finc_sum_of_the_years_digits_depreciation", NULL, FUNCTION,
+ /* Tooltip for the sum of the years digits depreciation button */
+ N_("Sum of the Years Digits Depreciation")},
+ {"finc_straight_line_depreciation", NULL, FUNCTION,
+ /* Tooltip for the straight line depreciation button */
+ N_("Straight Line Depreciation")},
+ {"finc_periodic_interest_rate", NULL, FUNCTION,
+ /* Tooltip for the periodic interest rate button */
+ N_("Periodic Interest Rate")},
+ {"finc_present_value", NULL, FUNCTION,
+ /* Tooltip for the present value button */
+ N_("Present Value")},
+ {"finc_periodic_payment", NULL, FUNCTION,
+ /* Tooltip for the periodic payment button */
+ N_("Periodic Payment")},
+ {"finc_gross_profit_margin", NULL, FUNCTION,
+ /* Tooltip for the gross profit margin button */
+ N_("Gross Profit Margin")},
+ {NULL, NULL, 0, NULL}
+};
+
+typedef enum {
+ CURRENCY_TARGET_UPPER,
+ CURRENCY_TARGET_LOWER
+} CurrencyTargetRow;
+
+/* The names of each field in the dialogs for the financial functions */
+static char *finc_dialog_fields[][5] = {
+ {"ctrm_pint", "ctrm_fv", "ctrm_pv", NULL, NULL},
+ {"ddb_cost", "ddb_life", "ddb_period", NULL, NULL},
+ {"fv_pmt", "fv_pint", "fv_n", NULL, NULL},
+ {"gpm_cost", "gpm_margin", NULL, NULL, NULL},
+ {"pmt_prin", "pmt_pint", "pmt_n", NULL, NULL},
+ {"pv_pmt", "pv_pint", "pv_n", NULL, NULL},
+ {"rate_fv", "rate_pv", "rate_n", NULL, NULL},
+ {"sln_cost", "sln_salvage", "sln_life", NULL, NULL},
+ {"syd_cost", "syd_salvage", "syd_life", "syd_period", NULL},
+ {"term_pmt", "term_fv", "term_pint", NULL, NULL},
+ {NULL, NULL, NULL, NULL, NULL}
+};
+
+
+MathButtons *
+math_buttons_new(MathEquation *equation)
+{
+ return g_object_new (math_buttons_get_type(), "equation", equation, NULL);
+}
+
+
+static void
+set_tint (GtkWidget *widget, GdkColor *tint, gint alpha)
+{
+ GtkStyle *style;
+ int j;
+ 
+ if (!widget)
+ return;
+
+ gtk_widget_ensure_style(widget);
+ style = gtk_widget_get_style(widget);
+ 
+ for (j = 0; j < 5; j++) {
+ GdkColor color;
+
+ color.red = (style->bg[j].red * (10 - alpha) + tint->red * alpha) / 10;
+ color.green = (style->bg[j].green * (10 - alpha) + tint->green * alpha) / 10;
+ color.blue = (style->bg[j].blue * (10 - alpha) + tint->blue * alpha) / 10;
+ gdk_colormap_alloc_color(gdk_colormap_get_system(), &color, FALSE, TRUE);
+ gtk_widget_modify_bg(widget, j, &color);
+ }
+}
+
+
+static void
+set_data(GtkBuilder *ui, const gchar *object_name, const gchar *name, const char *value)
+{
+ GObject *object;
+ object = gtk_builder_get_object(ui, object_name);
+ if (object)
+ g_object_set_data(object, name, GINT_TO_POINTER(value));
+}
+
+
+static void
+set_int_data(GtkBuilder *ui, const gchar *object_name, const gchar *name, gint value)
+{
+ GObject *object; 
+ object = gtk_builder_get_object(ui, object_name);
+ if (object)
+ g_object_set_data(object, name, GINT_TO_POINTER(value));
+}
+
+
+static void
+load_finc_dialogs(MathButtons *buttons)
+{
+ int i, j;
+
+ set_int_data(buttons->priv->financial_ui, "ctrm_dialog", "finc_dialog", FINC_CTRM_DIALOG);
+ set_int_data(buttons->priv->financial_ui, "ddb_dialog", "finc_dialog", FINC_DDB_DIALOG);
+ set_int_data(buttons->priv->financial_ui, "fv_dialog", "finc_dialog", FINC_FV_DIALOG);
+ set_int_data(buttons->priv->financial_ui, "gpm_dialog", "finc_dialog", FINC_GPM_DIALOG);
+ set_int_data(buttons->priv->financial_ui, "pmt_dialog", "finc_dialog", FINC_PMT_DIALOG);
+ set_int_data(buttons->priv->financial_ui, "pv_dialog", "finc_dialog", FINC_PV_DIALOG);
+ set_int_data(buttons->priv->financial_ui, "rate_dialog", "finc_dialog", FINC_RATE_DIALOG);
+ set_int_data(buttons->priv->financial_ui, "sln_dialog", "finc_dialog", FINC_SLN_DIALOG);
+ set_int_data(buttons->priv->financial_ui, "syd_dialog", "finc_dialog", FINC_SYD_DIALOG);
+ set_int_data(buttons->priv->financial_ui, "term_dialog", "finc_dialog", FINC_TERM_DIALOG);
+
+ for (i = 0; finc_dialog_fields[i][0] != NULL; i++) {
+ for (j = 0; finc_dialog_fields[i][j]; j++) {
+ GObject *o;
+ o = gtk_builder_get_object(buttons->priv->financial_ui, finc_dialog_fields[i][j]);
+ if(!o)
+ printf("missing '%s'\n", finc_dialog_fields[i][j]);
+ g_object_set_data(o, "finc_field", GINT_TO_POINTER(j));
+ g_object_set_data(o, "finc_dialog", GINT_TO_POINTER(i));
+ }
+ }
+}
+
+
+static void
+update_angle_label (MathButtons *buttons)
+{
+ MPNumber x;
+ MPNumber pi, max_value, min_value, fraction, input, output;
+ char *label, input_text[1024], output_text[1024];
+
+ if (!buttons->priv->angle_label)
+ return;
+
+ if (!math_equation_get_number(buttons->priv->equation, &x))
+ return;
+
+ mp_get_pi(&pi);
+ switch (math_equation_get_angle_units(buttons->priv->equation)) {
+ default:
+ case MP_DEGREES:
+ label = g_strdup("");
+ break;
+ case MP_RADIANS:
+ /* Clip to the range ±2π */
+ mp_multiply_integer(&pi, 2, &max_value);
+ mp_invert_sign(&max_value, &min_value);
+ if (!mp_is_equal(&x, &max_value) && !mp_is_equal(&x, &min_value)) {
+ mp_divide(&x, &max_value, &fraction);
+ mp_fractional_component(&fraction, &fraction);
+ mp_multiply(&fraction, &max_value, &input);
+ }
+ else {
+ mp_set_from_mp(&x, &input);
+ mp_set_from_integer(mp_is_negative(&input) ? -1 : 1, &fraction);
+ }
+ mp_cast_to_string(&input, 10, 10, 2, false, input_text, 1024);
+
+ mp_multiply_integer(&fraction, 360, &output);
+ mp_cast_to_string(&output, 10, 10, 2, false, output_text, 1024);
+ label = g_strdup_printf("%s radians = %s degrees", input_text, output_text);
+ break;
+ case MP_GRADIANS:
+ /* Clip to the range ±400 */
+ mp_set_from_integer(400, &max_value);
+ mp_invert_sign(&max_value, &min_value);
+ if (!mp_is_equal(&x, &max_value) && !mp_is_equal(&x, &min_value)) {
+ mp_divide(&x, &max_value, &fraction);
+ mp_fractional_component(&fraction, &fraction);
+ mp_multiply(&fraction, &max_value, &input);
+ }
+ else {
+ mp_set_from_mp(&x, &input);
+ mp_set_from_integer(mp_is_negative(&input) ? -1 : 1, &fraction);
+ }
+
+ mp_cast_to_string(&input, 10, 10, 2, false, input_text, 1024);
+
+ mp_multiply_integer(&fraction, 360, &output);
+ mp_cast_to_string(&output, 10, 10, 2, false, output_text, 1024);
+ label = g_strdup_printf("%s gradians = %s degrees", input_text, output_text);
+ break;
+ }
+
+ gtk_label_set_text(GTK_LABEL(buttons->priv->angle_label), label);
+ g_free(label);
+}
+
+
+static void
+update_bit_panel(MathButtons *buttons)
+{
+ MPNumber x;
+ gboolean enabled;
+ guint64 bits;
+ int i;
+ GString *label;
+ gint base;
+
+ if (!buttons->priv->bit_panel)
+ return;
+ 
+ enabled = math_equation_get_number(buttons->priv->equation, &x);
+
+ if (enabled) {
+ MPNumber max, fraction;
+
+ mp_set_from_unsigned_integer(G_MAXUINT64, &max);
+ mp_fractional_part(&x, &fraction);
+ if (mp_is_negative(&x) || mp_is_greater_than(&x, &max) || !mp_is_zero(&fraction))
+ enabled = FALSE;
+ else
+ bits = mp_cast_to_unsigned_int(&x);
+ }
+
+ gtk_widget_set_sensitive(buttons->priv->bit_panel, enabled);
+ gtk_widget_set_sensitive(buttons->priv->base_label, enabled);
+ 
+ if (!enabled)
+ return;
+
+ for (i = 0; i < MAXBITS; i++) {
+ const gchar *label;
+
+ if (bits & (1LL << (MAXBITS-i-1)))
+ label = " 1";
+ else
+ label = " 0";
+ gtk_label_set_text(GTK_LABEL(buttons->priv->bit_labels[i]), label);
+ }
+
+ base = math_equation_get_base(buttons->priv->equation); 
+ label = g_string_new("");
+ if (base != 8) {
+ if (label->len != 0)
+ g_string_append(label, " = ");
+ g_string_append_printf(label, "%lo", bits);
+ g_string_append(label, "₈");
+ }
+ if (base != 10) {
+ if (label->len != 0)
+ g_string_append(label, " = ");
+ g_string_append_printf(label, "%lu", bits);
+ g_string_append(label, "₁₀");
+ }
+ if (base != 16) {
+ if (label->len != 0)
+ g_string_append(label, " = ");
+ g_string_append_printf(label, "%lX", bits);
+ g_string_append(label, "₁₆");
+ }
+
+ gtk_label_set_text(GTK_LABEL(buttons->priv->base_label), label->str);
+ g_string_free(label, TRUE);
+}
+
+
+static void
+update_currency_label(MathButtons *buttons)
+{
+ MPNumber x, value;
+ char *label;
+
+ if (!buttons->priv->currency_label)
+ return;
+
+ if (!math_equation_get_number(buttons->priv->equation, &x))
+ return;
+ 
+ if (currency_convert(&x,
+ math_equation_get_source_currency(buttons->priv->equation),
+ math_equation_get_target_currency(buttons->priv->equation),
+ &value)) {
+ char input_text[1024], output_text[1024];
+ const char *source_symbol, *target_symbol;
+ int i;
+
+ mp_cast_to_string(&x, 10, 10, 2, false, input_text, 1024);
+ mp_cast_to_string(&value, 10, 10, 2, false, output_text, 1024);
+
+ for (i = 0; strcmp(math_equation_get_source_currency(buttons->priv->equation), currency_names[i].short_name) != 0; i++);
+ source_symbol = currency_names[i].symbol;
+ for (i = 0; strcmp(math_equation_get_target_currency(buttons->priv->equation), currency_names[i].short_name) != 0; i++);
+ target_symbol = currency_names[i].symbol;
+
+ label = g_strdup_printf("%s%s = %s%s",
+ source_symbol, input_text,
+ target_symbol, output_text);
+ }
+ else
+ label = g_strdup("");
+
+ gtk_label_set_text(GTK_LABEL(buttons->priv->currency_label), label);
+ g_free(label);
+}
+
+
+static void
+display_changed_cb(MathEquation *equation, GParamSpec *spec, MathButtons *buttons)
+{
+ update_angle_label(buttons);
+ update_currency_label(buttons);
+ update_bit_panel(buttons);
+}
+
+
+static void
+angle_unit_combobox_changed_cb(GtkWidget *combo, MathButtons *buttons)
+{
+ MPAngleUnit value;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+
+ model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+ gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo), &iter);
+ gtk_tree_model_get(model, &iter, 1, &value, -1);
+ math_equation_set_angle_units(buttons->priv->equation, value);
+}
+
+
+static void
+angle_unit_cb(MathEquation *equation, GParamSpec *spec, MathButtons *buttons)
+{
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ gboolean valid;
+
+ model = gtk_combo_box_get_model(GTK_COMBO_BOX(buttons->priv->angle_combo));
+ valid = gtk_tree_model_get_iter_first(model, &iter);
+
+ while (valid) {
+ gint v;
+
+ gtk_tree_model_get(model, &iter, 1, &v, -1);
+ if (v == math_equation_get_angle_units(buttons->priv->equation))
+ break;
+ valid = gtk_tree_model_iter_next(model, &iter);
+ }
+ if (!valid)
+ valid = gtk_tree_model_get_iter_first(model, &iter);
+
+ gtk_combo_box_set_active_iter(GTK_COMBO_BOX(buttons->priv->angle_combo), &iter);
+}
+
+
+static void
+base_combobox_changed_cb(GtkWidget *combo, MathButtons *buttons)
+{
+ gint value;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+
+ model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+ gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo), &iter);
+ gtk_tree_model_get(model, &iter, 1, &value, -1);
+
+ math_equation_set_base(buttons->priv->equation, value);
+}
+
+
+static void
+base_changed_cb(MathEquation *equation, GParamSpec *spec, MathButtons *buttons)
+{
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ gboolean valid;
+ 
+ if (buttons->priv->mode != PROGRAMMING)
+ return;
+
+ model = gtk_combo_box_get_model(GTK_COMBO_BOX(buttons->priv->base_combo));
+ valid = gtk_tree_model_get_iter_first(model, &iter);
+ buttons->priv->programming_base = math_equation_get_base(buttons->priv->equation);
+
+ while (valid) {
+ gint v;
+
+ gtk_tree_model_get(model, &iter, 1, &v, -1);
+ if (v == buttons->priv->programming_base)
+ break;
+ valid = gtk_tree_model_iter_next(model, &iter);
+ }
+ if (!valid)
+ valid = gtk_tree_model_get_iter_first(model, &iter);
+
+ gtk_combo_box_set_active_iter(GTK_COMBO_BOX(buttons->priv->base_combo), &iter);
+}
+
+
+static void
+source_currency_combo_changed_cb(GtkWidget *combo, MathButtons *buttons)
+{
+ gchar *value;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+
+ model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+ gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo), &iter);
+ gtk_tree_model_get(model, &iter, 0, &value, -1);
+
+ math_equation_set_source_currency(buttons->priv->equation, value);
+ g_free (value);
+}
+
+
+static void
+source_currency_changed_cb(MathEquation *equation, GParamSpec *spec, MathButtons *buttons)
+{
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ gboolean valid;
+ 
+ if (buttons->priv->mode != FINANCIAL)
+ return;
+
+ model = gtk_combo_box_get_model(GTK_COMBO_BOX(buttons->priv->source_currency_combo));
+ valid = gtk_tree_model_get_iter_first(model, &iter);
+
+ while (valid) {
+ gchar *v;
+ gboolean matched;
+
+ gtk_tree_model_get(model, &iter, 0, &v, -1);
+ matched = strcmp (math_equation_get_source_currency(buttons->priv->equation), v) == 0;
+ g_free (v);
+ if (matched)
+ break;
+ valid = gtk_tree_model_iter_next(model, &iter);
+ }
+ if (!valid)
+ valid = gtk_tree_model_get_iter_first(model, &iter);
+
+ gtk_combo_box_set_active_iter(GTK_COMBO_BOX(buttons->priv->source_currency_combo), &iter);
+ update_currency_label(buttons);
+}
+
+
+static void
+target_currency_combo_changed_cb(GtkWidget *combo, MathButtons *buttons)
+{
+ gchar *value;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+
+ model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+ gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo), &iter);
+ gtk_tree_model_get(model, &iter, 0, &value, -1);
+
+ math_equation_set_target_currency(buttons->priv->equation, value);
+ g_free (value);
+}
+
+
+static void
+target_currency_changed_cb(MathEquation *equation, GParamSpec *spec, MathButtons *buttons)
+{
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ gboolean valid;
+ 
+ if (buttons->priv->mode != FINANCIAL)
+ return;
+
+ model = gtk_combo_box_get_model(GTK_COMBO_BOX(buttons->priv->target_currency_combo));
+ valid = gtk_tree_model_get_iter_first(model, &iter);
+
+ while (valid) {
+ gchar *v;
+ gboolean matched;
+
+ gtk_tree_model_get(model, &iter, 0, &v, -1);
+ matched = strcmp (math_equation_get_target_currency(buttons->priv->equation), v) == 0;
+ g_free (v);
+ if (matched)
+ break;
+ valid = gtk_tree_model_iter_next(model, &iter);
+ }
+ if (!valid)
+ valid = gtk_tree_model_get_iter_first(model, &iter);
+
+ gtk_combo_box_set_active_iter(GTK_COMBO_BOX(buttons->priv->target_currency_combo), &iter);
+ update_currency_label(buttons);
+}
+
+
+static GtkWidget *
+load_mode(MathButtons *buttons, ButtonMode mode)
+{
+ GtkBuilder *builder, **builder_ptr;
+ gint i;
+ gchar *name;
+ const gchar *builder_file;
+ static gchar *objects[] = { "button_panel", "character_code_dialog", "currency_dialog",
+ "ctrm_dialog", "ddb_dialog", "fv_dialog", "gpm_dialog",
+ "pmt_dialog", "pv_dialog", "rate_dialog", "sln_dialog",
+ "syd_dialog", "term_dialog", "adjustment1", "adjustment2", NULL };
+ GtkWidget *widget, **panel;
+ GError *error = NULL;
+
+ switch (mode) {
+ case BASIC:
+ builder_ptr = &buttons->priv->basic_ui;
+ builder_file = UI_BASIC_FILE;
+ panel = &buttons->priv->bas_panel;
+ break;
+ case ADVANCED:
+ builder_ptr = &buttons->priv->advanced_ui;
+ builder_file = UI_ADVANCED_FILE;
+ panel = &buttons->priv->adv_panel;
+ break;
+ case FINANCIAL:
+ builder_ptr = &buttons->priv->financial_ui;
+ builder_file = UI_FINANCIAL_FILE;
+ panel = &buttons->priv->fin_panel;
+ break;
+ case PROGRAMMING:
+ builder_ptr = &buttons->priv->programming_ui;
+ builder_file = UI_PROGRAMMING_FILE;
+ panel = &buttons->priv->prog_panel;
+ break;
+ }
+ 
+ if (*panel)
+ return *panel;
+
+ builder = *builder_ptr = gtk_builder_new();
+ // FIXME: Show dialog if failed to load
+ gtk_builder_add_objects_from_file(builder, builder_file, objects, &error);
+ if (error) {
+ g_warning("Error loading button UI: %s", error->message);
+ g_clear_error(&error);
+ }
+ *panel = GET_WIDGET(builder, "button_panel");
+ gtk_box_pack_end(GTK_BOX(buttons), *panel, FALSE, TRUE, 0);
+
+ /* Configure buttons */
+ for (i = 0; button_data[i].widget_name != NULL; i++) {
+ GObject *object;
+ GtkWidget *button;
+
+ name = g_strdup_printf("calc_%s_button", button_data[i].widget_name);
+ object = gtk_builder_get_object(*builder_ptr, name);
+ g_free(name);
+
+ if (!object)
+ continue;
+ button = GTK_WIDGET(object);
+ if (button_data[i].data)
+ g_object_set_data(object, "calc_text", (gpointer) button_data[i].data);
+
+ if (button_data[i].tooltip)
+ gtk_widget_set_tooltip_text(button, _(button_data[i].tooltip));
+ 
+ atk_object_set_name (gtk_widget_get_accessible (button), button_data[i].widget_name);
+
+ switch (button_data[i].class) {
+ case NUMBER:
+ set_tint(button, &buttons->priv->color_numbers, 1); 
+ break;
+ case NUMBER_BOLD:
+ set_tint(button, &buttons->priv->color_numbers, 2);
+ break;
+ case OPERATOR:
+ set_tint(button, &buttons->priv->color_operator, 1); 
+ break;
+ case FUNCTION:
+ set_tint(button, &buttons->priv->color_function, 1); 
+ break;
+ case MEMORY:
+ set_tint(button, &buttons->priv->color_memory, 1);
+ break;
+ case GROUP:
+ set_tint(button, &buttons->priv->color_group, 1);
+ break;
+ case ACTION:
+ set_tint(button, &buttons->priv->color_action, 2);
+ break;
+ }
+ }
+
+ /* Set special button data */
+ for (i = 0; i < 16; i++) {
+ GtkWidget *button;
+
+ name = g_strdup_printf("calc_%d_button", i);
+ button = GET_WIDGET(builder, name);
+ if (button) {
+ g_object_set_data(G_OBJECT(button), "calc_digit", GINT_TO_POINTER(i));
+ set_tint(button, &buttons->priv->color_numbers, 1);
+ gtk_button_set_label(GTK_BUTTON(button), math_equation_get_digit_text(buttons->priv->equation, i));
+ }
+ g_free(name);
+ }
+ widget = GET_WIDGET(builder, "calc_numeric_point_button");
+ if (widget)
+ gtk_button_set_label(GTK_BUTTON(widget), math_equation_get_numeric_point_text(buttons->priv->equation));
+ 
+ widget = GET_WIDGET(builder, "calc_superscript_button");
+ if (widget) {
+ buttons->priv->superscript_toggles = g_list_append(buttons->priv->superscript_toggles, widget);
+ if (math_equation_get_number_mode(buttons->priv->equation) == SUPERSCRIPT)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE);
+ }
+ widget = GET_WIDGET(builder, "calc_subscript_button");
+ if (widget) {
+ buttons->priv->subscript_toggles = g_list_append(buttons->priv->subscript_toggles, widget);
+ if (math_equation_get_number_mode(buttons->priv->equation) == SUBSCRIPT)
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE);
+ }
+ 
+ if (mode == ADVANCED) {
+ GtkListStore *model;
+ GtkTreeIter iter;
+ GtkCellRenderer *renderer;
+
+ buttons->priv->angle_label = GET_WIDGET(builder, "angle_label");
+
+ buttons->priv->angle_combo = GET_WIDGET(builder, "angle_units_combo");
+ model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
+ gtk_combo_box_set_model(GTK_COMBO_BOX(buttons->priv->angle_combo), GTK_TREE_MODEL(model));
+ gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0,
+ /* Advanced buttons: Angle unit combo box: Use degrees for trigonometric calculations */
+ _("Degrees"), 1, MP_DEGREES, -1);
+ gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0,
+ /* Advanced buttons: Angle unit combo box: Use radians for trigonometric calculations */
+ _("Radians"), 1, MP_RADIANS, -1);
+ gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0,
+ /* Advanced buttons: Angle unit combo box: Use gradians for trigonometric calculations */
+ _("Gradians"), 1, MP_GRADIANS, -1);
+ renderer = gtk_cell_renderer_text_new();
+ gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(buttons->priv->angle_combo), renderer, TRUE);
+ gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(buttons->priv->angle_combo), renderer, "text", 0);
+
+ g_signal_connect(buttons->priv->angle_combo, "changed", G_CALLBACK(angle_unit_combobox_changed_cb), buttons);
+ g_signal_connect(buttons->priv->equation, "notify::angle-units", G_CALLBACK(angle_unit_cb), buttons);
+ angle_unit_cb(buttons->priv->equation, NULL, buttons);
+ }
+
+ if (mode == PROGRAMMING) {
+ GtkListStore *model;
+ GtkTreeIter iter;
+ GtkCellRenderer *renderer;
+
+ buttons->priv->base_label = GET_WIDGET(builder, "base_label");
+ buttons->priv->character_code_dialog = GET_WIDGET(builder, "character_code_dialog");
+ buttons->priv->character_code_entry = GET_WIDGET(builder, "character_code_entry");
+
+ buttons->priv->bit_panel = GET_WIDGET(builder, "bit_table");
+ for (i = 0; i < MAXBITS; i++) {
+ name = g_strdup_printf("bit_label_%d", i);
+ buttons->priv->bit_labels[i] = GET_WIDGET(builder, name);
+ g_free(name);
+ name = g_strdup_printf("bit_eventbox_%d", i);
+ set_int_data(builder, name, "bit_index", i);
+ }
+
+ buttons->priv->base_combo = GET_WIDGET(builder, "base_combo");
+ model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT);
+ gtk_combo_box_set_model(GTK_COMBO_BOX(buttons->priv->base_combo), GTK_TREE_MODEL(model));
+ gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0,
+ /* Number display mode combo: Binary, e.g. 10011010010₂ */
+ _("Binary"), 1, 2, -1);
+ gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0,
+ /* Number display mode combo: Octal, e.g. 2322₈ */
+ _("Octal"), 1, 8, -1);
+ gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0,
+ /* Number display mode combo: Decimal, e.g. 1234 */
+ _("Decimal"), 1, 10, -1);
+ gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0,
+ /* Number display mode combo: Hexadecimal, e.g. 4D2₁₆ */
+ _("Hexadecimal"), 1, 16, -1);
+ renderer = gtk_cell_renderer_text_new();
+ gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(buttons->priv->base_combo), renderer, TRUE);
+ gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(buttons->priv->base_combo), renderer, "text", 0);
+
+ g_signal_connect(buttons->priv->base_combo, "changed", G_CALLBACK(base_combobox_changed_cb), buttons);
+ g_signal_connect(buttons->priv->equation, "notify::base", G_CALLBACK(base_changed_cb), buttons);
+ base_changed_cb(buttons->priv->equation, NULL, buttons);
+ }
+
+ /* Setup financial functions */
+ if (mode == FINANCIAL) {
+ GtkListStore *model;
+ GtkCellRenderer *renderer;
+
+ load_finc_dialogs(buttons);
+
+ buttons->priv->source_currency_combo = GET_WIDGET(builder, "source_currency_combo");
+ buttons->priv->target_currency_combo = GET_WIDGET(builder, "target_currency_combo");
+ buttons->priv->currency_label = GET_WIDGET(builder, "currency_label");
+
+ model = gtk_list_store_new(1, G_TYPE_STRING);
+
+ for (i = 0; currency_names[i].short_name != NULL; i++) {
+ GtkTreeIter iter;
+
+ gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0, currency_names[i].short_name, -1);
+ }
+
+ gtk_combo_box_set_model(GTK_COMBO_BOX(buttons->priv->source_currency_combo), GTK_TREE_MODEL(model));
+ gtk_combo_box_set_model(GTK_COMBO_BOX(buttons->priv->target_currency_combo), GTK_TREE_MODEL(model));
+
+ renderer = gtk_cell_renderer_text_new();
+ gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(buttons->priv->source_currency_combo), renderer, TRUE);
+ gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(buttons->priv->source_currency_combo), renderer, "text", 0);
+ renderer = gtk_cell_renderer_text_new();
+ gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(buttons->priv->target_currency_combo), renderer, TRUE);
+ gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(buttons->priv->target_currency_combo), renderer, "text", 0);
+
+ g_signal_connect(buttons->priv->source_currency_combo, "changed", G_CALLBACK(source_currency_combo_changed_cb), buttons);
+ g_signal_connect(buttons->priv->target_currency_combo, "changed", G_CALLBACK(target_currency_combo_changed_cb), buttons);
+ g_signal_connect(buttons->priv->equation, "notify::source-currency", G_CALLBACK(source_currency_changed_cb), buttons);
+ g_signal_connect(buttons->priv->equation, "notify::target-currency", G_CALLBACK(target_currency_changed_cb), buttons);
+ source_currency_changed_cb(buttons->priv->equation, NULL, buttons);
+ target_currency_changed_cb(buttons->priv->equation, NULL, buttons);
+
+ set_data(builder, "calc_finc_compounding_term_button", "finc_dialog", "ctrm_dialog");
+ set_data(builder, "calc_finc_double_declining_depreciation_button", "finc_dialog", "ddb_dialog");
+ set_data(builder, "calc_finc_future_value_button", "finc_dialog", "fv_dialog");
+ set_data(builder, "calc_finc_gross_profit_margin_button", "finc_dialog", "gpm_dialog");
+ set_data(builder, "calc_finc_periodic_payment_button", "finc_dialog", "pmt_dialog");
+ set_data(builder, "calc_finc_present_value_button", "finc_dialog", "pv_dialog");
+ set_data(builder, "calc_finc_periodic_interest_rate_button", "finc_dialog", "rate_dialog");
+ set_data(builder, "calc_finc_straight_line_depreciation_button", "finc_dialog", "sln_dialog");
+ set_data(builder, "calc_finc_sum_of_the_years_digits_depreciation_button", "finc_dialog", "syd_dialog");
+ set_data(builder, "calc_finc_term_button", "finc_dialog", "term_dialog");
+ }
+
+ gtk_builder_connect_signals(builder, buttons);
+
+ display_changed_cb(buttons->priv->equation, NULL, buttons);
+ 
+ return *panel;
+}
+
+
+
+static void
+load_buttons(MathButtons *buttons)
+{
+ GtkWidget *panel;
+
+ if (!gtk_widget_get_visible(GTK_WIDGET(buttons)))
+ return;
+
+ panel = load_mode(buttons, buttons->priv->mode);
+ if (buttons->priv->active_panel == panel)
+ return;
+
+ /* Hide old buttons */
+ if (buttons->priv->active_panel)
+ gtk_widget_hide(buttons->priv->active_panel);
+
+ /* Load and display new buttons */
+ buttons->priv->active_panel = panel;
+ if (panel)
+ gtk_widget_show(panel);
+}
+
+
+void
+math_buttons_set_mode(MathButtons *buttons, ButtonMode mode)
+{
+ ButtonMode old_mode;
+ 
+ if (buttons->priv->mode == mode)
+ return;
+
+ old_mode = buttons->priv->mode;
+ buttons->priv->mode = mode;
+ 
+ if (mode == PROGRAMMING)
+ math_equation_set_base(buttons->priv->equation, buttons->priv->programming_base);
+ else
+ math_equation_set_base(buttons->priv->equation, 10);
+
+ load_buttons(buttons);
+
+ g_object_notify(G_OBJECT(buttons), "mode");
+}
+
+
+ButtonMode
+math_buttons_get_mode(MathButtons *buttons)
+{
+ return buttons->priv->mode;
+}
+
+
+void
+math_buttons_set_programming_base(MathButtons *buttons, gint base)
+{
+ buttons->priv->programming_base = base;
+}
+
+
+gint
+math_buttons_get_programming_base(MathButtons *buttons)
+{
+ return buttons->priv->programming_base;
+}
+
+
+void exponent_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+exponent_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ math_equation_insert_exponent(buttons->priv->equation);
+}
+
+
+void subtract_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+subtract_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ math_equation_insert_subtract(buttons->priv->equation); 
+}
+
+
+void button_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+button_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ math_equation_insert(buttons->priv->equation, g_object_get_data(G_OBJECT(widget), "calc_text"));
+}
+
+
+void solve_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+solve_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ math_equation_solve(buttons->priv->equation);
+}
+
+
+void clear_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+clear_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ math_equation_clear(buttons->priv->equation);
+}
+
+
+void delete_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+delete_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ math_equation_delete(buttons->priv->equation);
+}
+
+
+void undo_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+undo_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ math_equation_undo(buttons->priv->equation);
+}
+
+
+static void
+shift_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ math_equation_shift(buttons->priv->equation, GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "shiftcount")));
+}
+
+
+static void
+button_menu_position_func(GtkMenu *menu, gint *x, gint *y,
+ gboolean *push_in, gpointer user_data)
+{
+ GtkWidget *button = user_data;
+ GtkAllocation allocation;
+ GdkPoint loc;
+ gint border;
+ 
+ gdk_window_get_origin(gtk_widget_get_window(button), &loc.x, &loc.y);
+ border = gtk_container_get_border_width(GTK_CONTAINER(button));
+ gtk_widget_get_allocation(button, &allocation);
+ *x = loc.x + allocation.x + border;
+ *y = loc.y + allocation.y + border;
+}
+
+
+static void
+popup_button_menu(GtkWidget *widget, GtkMenu *menu)
+{
+ gtk_menu_popup(menu, NULL, NULL,
+ button_menu_position_func, widget, 1, gtk_get_current_event_time());
+}
+
+
+static void
+save_variable_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ printf("save\n");
+}
+
+
+static void
+delete_variable_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ printf("delete\n");
+}
+
+
+static GtkWidget *
+make_register_menu_item(MathButtons *buttons, const gchar *name, const MPNumber *value, gboolean can_modify, GCallback callback)
+{
+ gchar text[1024] = "", *mstr;
+ GtkWidget *item, *label;
+
+ if (value) {
+ display_make_number(buttons->priv->equation, text, 1024, value);
+ mstr = g_strdup_printf("<span weight=\"bold\">%s</span> = %s", name, text);
+ }
+ else
+ mstr = g_strdup_printf("<span weight=\"bold\">%s</span>", name);
+ label = gtk_label_new(mstr);
+ gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
+ gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
+ g_free(mstr);
+
+ item = gtk_menu_item_new();
+
+ // FIXME: Buttons don't work inside menus...
+ if (0) {//can_modify) {
+ GtkWidget *hbox, *button;
+
+ hbox = gtk_hbox_new(FALSE, 6);
+ gtk_container_add(GTK_CONTAINER(item), hbox);
+
+ gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
+
+ button = gtk_button_new();
+ gtk_button_set_image(GTK_BUTTON(button), gtk_image_new_from_stock(GTK_STOCK_DELETE, GTK_ICON_SIZE_MENU));
+ gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
+ gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, TRUE, 0);
+ g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(delete_variable_cb), buttons);
+
+ button = gtk_button_new();
+ gtk_button_set_image(GTK_BUTTON(button), gtk_image_new_from_stock(GTK_STOCK_SAVE, GTK_ICON_SIZE_MENU));
+ gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
+ gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, TRUE, 0);
+ g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(save_variable_cb), buttons);
+ }
+ else
+ gtk_container_add(GTK_CONTAINER(item), label);
+
+ g_object_set_data(G_OBJECT(item), "register_id", g_strdup(name)); // FIXME: Memory leak
+ g_signal_connect(item, "activate", callback, buttons);
+ 
+ return item;
+}
+
+
+static void
+store_menu_cb(GtkMenuItem *menu, MathButtons *buttons)
+{
+ math_equation_store(buttons->priv->equation, g_object_get_data(G_OBJECT(menu), "register_id"));
+}
+
+
+void store_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+store_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ int i;
+ GtkWidget *menu;
+ GtkWidget *item;
+ gchar **names;
+
+ menu = gtk_menu_new();
+ gtk_menu_set_reserve_toggle_size(GTK_MENU(menu), FALSE);
+ set_tint(menu, &buttons->priv->color_memory, 1);
+
+ names = math_variables_get_names(math_equation_get_variables(buttons->priv->equation));
+ if (names[0] == NULL) {
+ item = gtk_menu_item_new_with_label(/* Text shown in store menu when no variables defined */
+ _("No variables defined"));
+ gtk_widget_set_sensitive(item, FALSE);
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
+ } 
+ for (i = 0; names[i]; i++) {
+ MPNumber *value;
+ value = math_variables_get_value(math_equation_get_variables(buttons->priv->equation), names[i]);
+ item = make_register_menu_item(buttons, names[i], value, TRUE, G_CALLBACK(store_menu_cb));
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
+ }
+
+ g_strfreev(names);
+
+ // FIXME
+ //item = gtk_menu_item_new_with_label(_("Add variable"));
+ //gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
+
+ gtk_widget_show_all(menu);
+ popup_button_menu(widget, GTK_MENU(menu));
+}
+
+
+static void
+recall_menu_cb(GtkMenuItem *menu, MathButtons *buttons)
+{
+ math_equation_recall(buttons->priv->equation, g_object_get_data(G_OBJECT(menu), "register_id")); 
+}
+
+
+void recall_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+recall_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ int i;
+ GtkWidget *menu;
+ GtkWidget *item;
+ gchar **names;
+
+ menu = gtk_menu_new();
+ gtk_menu_set_reserve_toggle_size(GTK_MENU(menu), FALSE);
+ set_tint(menu, &buttons->priv->color_memory, 1);
+
+ names = math_variables_get_names(math_equation_get_variables(buttons->priv->equation));
+ if (names[0] == NULL) {
+ item = gtk_menu_item_new_with_label(/* Text shown in recall menu when no variables defined */
+ _("No variables defined"));
+ gtk_widget_set_sensitive(item, FALSE);
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
+ } 
+ for (i = 0; names[i]; i++) {
+ MPNumber *value;
+ value = math_variables_get_value(math_equation_get_variables(buttons->priv->equation), names[i]);
+ item = make_register_menu_item(buttons, names[i], value, TRUE, G_CALLBACK(recall_menu_cb));
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
+ }
+
+ g_strfreev(names);
+
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
+ item = make_register_menu_item(buttons, "ans", math_equation_get_answer(buttons->priv->equation), FALSE, G_CALLBACK(recall_menu_cb));
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
+ item = make_register_menu_item(buttons, "rand", NULL, FALSE, G_CALLBACK(recall_menu_cb));
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
+
+ gtk_widget_show_all(menu);
+ popup_button_menu(widget, GTK_MENU(menu));
+}
+
+
+void shift_left_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+shift_left_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ if (!buttons->priv->shift_left_menu) {
+ gint i;
+ GtkWidget *menu;
+
+ menu = buttons->priv->shift_left_menu = gtk_menu_new();
+ gtk_menu_set_reserve_toggle_size(GTK_MENU(menu), FALSE);
+ set_tint(menu, &buttons->priv->color_action, 1);
+
+ for (i = 1; i < 16; i++) {
+ GtkWidget *item, *label;
+ gchar *format, *text;
+
+ if (i < 10) {
+ /* Left Shift Popup: Menu item to shift left by n places (n < 10) */
+ format = ngettext("_%d place", "_%d places", i);
+ }
+ else {
+ /* Left Shift Popup: Menu item to shift left by n places (n >= 10) */
+ format = ngettext("%d place", "%d places", i);
+ }
+ text = g_strdup_printf(format, i);
+ label = gtk_label_new_with_mnemonic(text);
+
+ item = gtk_menu_item_new();
+ g_object_set_data(G_OBJECT(item), "shiftcount", GINT_TO_POINTER(i));
+ gtk_container_add(GTK_CONTAINER(item), label);
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
+ g_signal_connect(item, "activate", G_CALLBACK(shift_cb), buttons);
+
+ gtk_widget_show(label);
+ gtk_widget_show(item);
+ g_free(text);
+ }
+ }
+
+ popup_button_menu(widget, GTK_MENU(buttons->priv->shift_left_menu));
+}
+
+
+void shift_right_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+shift_right_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ if (!buttons->priv->shift_right_menu) {
+ gint i;
+ GtkWidget *menu;
+
+ menu = buttons->priv->shift_right_menu = gtk_menu_new();
+ gtk_menu_set_reserve_toggle_size(GTK_MENU(menu), FALSE);
+ set_tint(menu, &buttons->priv->color_action, 1);
+
+ for (i = 1; i < 16; i++) {
+ GtkWidget *item, *label;
+ gchar *format, *text;
+
+ if (i < 10) {
+ /* Right Shift Popup: Menu item to shift right by n places (n < 10) */
+ format = ngettext("_%d place", "_%d places", i);
+ }
+ else {
+ /* Right Shift Popup: Menu item to shift right by n places (n >= 10) */
+ format = ngettext("%d place", "%d places", i);
+ }
+ text = g_strdup_printf(format, i);
+ label = gtk_label_new_with_mnemonic(text);
+
+ item = gtk_menu_item_new();
+ g_object_set_data(G_OBJECT(item), "shiftcount", GINT_TO_POINTER(-i));
+ gtk_container_add(GTK_CONTAINER(item), label);
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
+ g_signal_connect(item, "activate", G_CALLBACK(shift_cb), buttons);
+
+ gtk_widget_show(label);
+ gtk_widget_show(item);
+ g_free(text);
+ }
+ }
+
+ popup_button_menu(widget, GTK_MENU(buttons->priv->shift_right_menu)); 
+}
+
+
+static void
+insert_function_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ math_equation_insert(buttons->priv->equation, g_object_get_data(G_OBJECT(widget), "function"));
+}
+
+
+void function_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+function_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ if (!buttons->priv->function_menu) {
+ gint i;
+ GtkWidget *menu;
+ struct 
+ {
+ gchar *name, *function;
+ } functions[] = 
+ {
+ { /* Tooltip for the integer component button */
+ N_("Integer Component"), "int " },
+ { /* Tooltip for the fractional component button */
+ N_("Fractional Component"), "frac " },
+ { /* Tooltip for the round button */
+ N_("Round"), "round " },
+ { /* Tooltip for the floor button */
+ N_("Floor"), "floor " },
+ { /* Tooltip for the ceiling button */
+ N_("Ceiling"), "ceil " },
+ { /* Tooltip for the ceiling button */
+ N_("Sign"), "sgn " },
+ { NULL, NULL }
+ };
+
+ menu = buttons->priv->function_menu = gtk_menu_new();
+ gtk_menu_set_reserve_toggle_size(GTK_MENU(menu), FALSE);
+ set_tint(menu, &buttons->priv->color_function, 1);
+
+ for (i = 0; functions[i].name != NULL; i++) {
+ GtkWidget *item;
+ 
+ item = gtk_menu_item_new_with_label(_(functions[i].name));
+ g_object_set_data(G_OBJECT(item), "function", g_strdup (functions[i].function));
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
+ g_signal_connect(item, "activate", G_CALLBACK(insert_function_cb), buttons);
+ gtk_widget_show(item);
+ }
+ }
+
+ popup_button_menu(widget, GTK_MENU(buttons->priv->function_menu)); 
+}
+
+
+void factorize_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+factorize_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ math_equation_factorize (buttons->priv->equation);
+}
+
+
+void digit_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+digit_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ math_equation_insert_digit(buttons->priv->equation, GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "calc_digit")));
+}
+
+
+void numeric_point_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+numeric_point_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ math_equation_insert_numeric_point(buttons->priv->equation);
+}
+
+
+
+void finc_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+finc_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ gchar *name;
+
+ name = g_object_get_data(G_OBJECT(widget), "finc_dialog");
+ gtk_dialog_run(GTK_DIALOG(GET_WIDGET(buttons->priv->financial_ui, name)));
+ gtk_widget_hide(GTK_WIDGET(GET_WIDGET(buttons->priv->financial_ui, name)));
+}
+
+
+void insert_character_code_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+insert_character_code_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ gtk_window_present(GTK_WINDOW(buttons->priv->character_code_dialog));
+}
+
+
+void finc_activate_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+finc_activate_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ gint dialog, field;
+
+ dialog = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "finc_dialog"));
+ field = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "finc_field"));
+
+ if (finc_dialog_fields[dialog][field+1] == NULL) {
+ GtkWidget *dialog_widget;
+ dialog_widget = gtk_widget_get_toplevel(widget);
+ if (gtk_widget_is_toplevel (dialog_widget)) {
+ gtk_dialog_response(GTK_DIALOG(dialog_widget),
+ GTK_RESPONSE_OK);
+ return;
+ }
+ }
+ else {
+ GtkWidget *next_widget;
+ next_widget = GET_WIDGET(buttons->priv->financial_ui, finc_dialog_fields[dialog][field+1]);
+ gtk_widget_grab_focus(next_widget);
+ }
+}
+
+
+void finc_response_cb(GtkWidget *widget, gint response_id, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+finc_response_cb(GtkWidget *widget, gint response_id, MathButtons *buttons)
+{
+ int dialog;
+ int i;
+ MPNumber arg[4];
+ GtkWidget *entry;
+
+ if (response_id != GTK_RESPONSE_OK)
+ return;
+
+ dialog = GPOINTER_TO_INT (g_object_get_data(G_OBJECT(widget), "finc_dialog"));
+
+ for (i = 0; i < 4; i++) {
+ if (finc_dialog_fields[dialog][i] == NULL) {
+ continue;
+ }
+ entry = GET_WIDGET(buttons->priv->financial_ui, finc_dialog_fields[dialog][i]);
+ mp_set_from_string(gtk_entry_get_text(GTK_ENTRY(entry)), 10, &arg[i]);
+ gtk_entry_set_text(GTK_ENTRY(entry), "0");
+ }
+ gtk_widget_grab_focus(GET_WIDGET(buttons->priv->financial_ui, finc_dialog_fields[dialog][0]));
+
+ do_finc_expression(buttons->priv->equation, dialog, &arg[0], &arg[1], &arg[2], &arg[3]);
+}
+
+
+void character_code_dialog_response_cb(GtkWidget *dialog, gint response_id, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+character_code_dialog_response_cb(GtkWidget *dialog, gint response_id, MathButtons *buttons)
+{
+ const gchar *text;
+
+ text = gtk_entry_get_text(GTK_ENTRY(buttons->priv->character_code_entry));
+
+ if (response_id == GTK_RESPONSE_OK) { 
+ MPNumber x;
+ int i = 0;
+
+ mp_set_from_integer(0, &x);
+ while (TRUE) {
+ mp_add_integer(&x, text[i], &x);
+ if (text[i+1]) {
+ mp_shift(&x, 8, &x);
+ i++;
+ }
+ else
+ break;
+ }
+
+ math_equation_insert_number(buttons->priv->equation, &x);
+ }
+
+ gtk_widget_hide(dialog);
+}
+
+
+void character_code_dialog_activate_cb(GtkWidget *entry, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+character_code_dialog_activate_cb(GtkWidget *entry, MathButtons *buttons)
+{
+ character_code_dialog_response_cb(buttons->priv->character_code_dialog, GTK_RESPONSE_OK, buttons);
+}
+
+
+gboolean character_code_dialog_delete_cb(GtkWidget *dialog, GdkEvent *event, MathButtons *buttons);
+G_MODULE_EXPORT
+gboolean
+character_code_dialog_delete_cb(GtkWidget *dialog, GdkEvent *event, MathButtons *buttons)
+{
+ character_code_dialog_response_cb(dialog, GTK_RESPONSE_CANCEL, buttons);
+ return TRUE;
+}
+
+
+gboolean bit_toggle_cb(GtkWidget *event_box, GdkEventButton *event, MathButtons *buttons);
+G_MODULE_EXPORT
+gboolean
+bit_toggle_cb(GtkWidget *event_box, GdkEventButton *event, MathButtons *buttons)
+{
+ math_equation_toggle_bit(buttons->priv->equation, GPOINTER_TO_INT(g_object_get_data(G_OBJECT(event_box), "bit_index")));
+ return TRUE;
+}
+
+
+
+void set_superscript_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+set_superscript_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
+ math_equation_set_number_mode(buttons->priv->equation, SUPERSCRIPT);
+ else if (math_equation_get_number_mode(buttons->priv->equation) == SUPERSCRIPT)
+ math_equation_set_number_mode(buttons->priv->equation, NORMAL);
+}
+
+
+void set_subscript_cb(GtkWidget *widget, MathButtons *buttons);
+G_MODULE_EXPORT
+void
+set_subscript_cb(GtkWidget *widget, MathButtons *buttons)
+{
+ if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
+ math_equation_set_number_mode(buttons->priv->equation, SUBSCRIPT);
+ else if (math_equation_get_number_mode(buttons->priv->equation) == SUBSCRIPT)
+ math_equation_set_number_mode(buttons->priv->equation, NORMAL);
+}
+
+
+static void
+number_mode_changed_cb(MathEquation *equation, GParamSpec *spec, MathButtons *buttons)
+{
+ GList *i;
+ NumberMode mode;
+ 
+ mode = math_equation_get_number_mode(equation);
+
+ for (i = buttons->priv->superscript_toggles; i; i = i->next) {
+ GtkWidget *widget = i->data;
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), mode == SUPERSCRIPT);
+ }
+ for (i = buttons->priv->subscript_toggles; i; i = i->next) {
+ GtkWidget *widget = i->data;
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), mode == SUBSCRIPT);
+ }
+}
+
+
+static void
+math_buttons_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ MathButtons *self;
+
+ self = MATH_BUTTONS (object);
+
+ switch (prop_id) {
+ case PROP_EQUATION:
+ self->priv->equation = g_value_get_object (value);
+ math_buttons_set_mode(self, self->priv->mode);
+ g_signal_connect(self->priv->equation, "notify::display", G_CALLBACK(display_changed_cb), self);
+ g_signal_connect(self->priv->equation, "notify::number-mode", G_CALLBACK(number_mode_changed_cb), self);
+ g_signal_connect(self->priv->equation, "notify::angle-units", G_CALLBACK(display_changed_cb), self);
+ g_signal_connect(self->priv->equation, "notify::number-format", G_CALLBACK(display_changed_cb), self);
+ number_mode_changed_cb(self->priv->equation, NULL, self);
+ display_changed_cb(self->priv->equation, NULL, self);
+ break;
+ case PROP_MODE:
+ math_buttons_set_mode(self, g_value_get_int (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+
+static void
+math_buttons_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ MathButtons *self;
+
+ self = MATH_BUTTONS (object);
+
+ switch (prop_id) {
+ case PROP_EQUATION:
+ g_value_set_object (value, self->priv->equation);
+ break;
+ case PROP_MODE:
+ g_value_set_int (value, self->priv->mode);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+
+static void
+math_buttons_class_init (MathButtonsClass *klass)
+{
+ static GEnumValue button_mode_values[] =
+ {
+ {BASIC, "basic", "basic"},
+ {ADVANCED, "advanced", "advanced"},
+ {FINANCIAL, "financial", "financial"},
+ {PROGRAMMING, "programming", "programming"},
+ {0, NULL, NULL}
+ };
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->get_property = math_buttons_get_property;
+ object_class->set_property = math_buttons_set_property;
+
+ g_type_class_add_private (klass, sizeof (MathButtonsPrivate));
+
+ button_mode_type = g_enum_register_static("ButtonMode", button_mode_values);
+
+ g_object_class_install_property (object_class,
+ PROP_EQUATION,
+ g_param_spec_object ("equation",
+ "equation",
+ "Equation being controlled",
+ math_equation_get_type(),
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+ g_object_class_install_property (object_class,
+ PROP_MODE,
+ g_param_spec_enum ("mode",
+ "mode",
+ "Button mode",
+ button_mode_type,
+ BASIC,
+ G_PARAM_READWRITE));
+}
+
+
+static void
+math_buttons_init (MathButtons *buttons)
+{
+ buttons->priv = G_TYPE_INSTANCE_GET_PRIVATE (buttons, math_buttons_get_type(), MathButtonsPrivate);
+ buttons->priv->programming_base = 10;
+ gdk_color_parse("#0000FF", &buttons->priv->color_numbers);
+ gdk_color_parse("#00FF00", &buttons->priv->color_action);
+ gdk_color_parse("#FF0000", &buttons->priv->color_operator);
+ gdk_color_parse("#00FFFF", &buttons->priv->color_function);
+ gdk_color_parse("#FF00FF", &buttons->priv->color_memory);
+ gdk_color_parse("#FFFFFF", &buttons->priv->color_group);
+ g_signal_connect(G_OBJECT(buttons), "show", G_CALLBACK(load_buttons), NULL);
+}
diff --git a/src/math-buttons.h b/src/math-buttons.h
new file mode 100644
index 0000000..7e85e33
--- /dev/null
+++ b/src/math-buttons.h
@@ -0,0 +1,62 @@
+/* Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef MATH_BUTTONS_H
+#define MATH_BUTTONS_H
+
+#include <glib-object.h>
+#include <gtk/gtk.h>
+#include "math-equation.h"
+
+G_BEGIN_DECLS
+
+#define MATH_BUTTONS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), math_buttons_get_type(), MathButtons))
+
+typedef struct MathButtonsPrivate MathButtonsPrivate;
+
+typedef struct
+{
+ GtkVBox parent_instance;
+ MathButtonsPrivate *priv;
+} MathButtons;
+
+typedef struct
+{
+ GtkVBoxClass parent_class;
+} MathButtonsClass;
+
+typedef enum {
+ BASIC,
+ ADVANCED,
+ FINANCIAL,
+ PROGRAMMING
+} ButtonMode;
+
+GType math_buttons_get_type(void);
+
+MathButtons *math_buttons_new(MathEquation *equation);
+
+void math_buttons_set_mode(MathButtons *buttons, ButtonMode mode);
+
+ButtonMode math_buttons_get_mode(MathButtons *buttons);
+
+void math_buttons_set_programming_base(MathButtons *buttons, gint base);
+
+gint math_buttons_get_programming_base(MathButtons *buttons);
+
+#endif /* MATH_BUTTONS_H */
diff --git a/src/math-display.c b/src/math-display.c
new file mode 100644
index 0000000..62f0218
--- /dev/null
+++ b/src/math-display.c
@@ -0,0 +1,358 @@
+/* Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <string.h>
+#include <glib/gi18n.h>
+#include <gdk/gdkkeysyms.h>
+
+#include "math-display.h"
+
+enum {
+ PROP_0,
+ PROP_EQUATION
+};
+
+struct MathDisplayPrivate
+{
+ /* Equation being displayed */
+ MathEquation *equation;
+
+ /* Display widget */
+ GtkWidget *text_view;
+
+ /* Buffer that shows errors etc */
+ GtkTextBuffer *info_buffer;
+};
+
+G_DEFINE_TYPE (MathDisplay, math_display, GTK_TYPE_VBOX);
+
+#define GET_WIDGET(ui, name) GTK_WIDGET(gtk_builder_get_object(ui, name))
+
+MathDisplay *
+math_display_new()
+{
+ return g_object_new (math_display_get_type(), "equation", math_equation_new(), NULL);
+}
+
+
+MathDisplay *
+math_display_new_with_equation(MathEquation *equation)
+{
+ return g_object_new (math_display_get_type(), "equation", equation, NULL);
+}
+
+
+MathEquation *
+math_display_get_equation(MathDisplay *display)
+{
+ return display->priv->equation;
+}
+
+
+static gboolean
+display_key_press_cb(GtkWidget *widget, GdkEventKey *event, MathDisplay *display)
+{
+ int state;
+ guint32 c;
+
+ state = event->state & (GDK_CONTROL_MASK | GDK_MOD1_MASK);
+ c = gdk_keyval_to_unicode(event->keyval);
+
+ /* Solve on enter */
+ if (event->keyval == GDK_Return || event->keyval == GDK_KP_Enter) {
+ math_equation_solve(display->priv->equation);
+ return TRUE;
+ }
+
+ /* Clear on escape */
+ if ((event->keyval == GDK_Escape && state == 0) ||
+ (event->keyval == GDK_BackSpace && state == GDK_CONTROL_MASK) ||
+ (event->keyval == GDK_Delete && state == GDK_SHIFT_MASK)) {
+ math_equation_clear(display->priv->equation);
+ return TRUE;
+ }
+
+ /* Substitute */
+ if (state == 0) {
+ if (c == '*') {
+ math_equation_insert(display->priv->equation, "×");
+ return TRUE;
+ }
+ if (c == '/') {
+ math_equation_insert(display->priv->equation, "÷");
+ return TRUE;
+ }
+ if (c == '-') {
+ math_equation_insert_subtract(display->priv->equation);
+ return TRUE;
+ }
+ }
+
+ /* Shortcuts */
+ if (state == GDK_CONTROL_MASK) {
+ switch(event->keyval)
+ {
+ case GDK_bracketleft:
+ math_equation_insert(display->priv->equation, "⌈");
+ return TRUE;
+ case GDK_bracketright:
+ math_equation_insert(display->priv->equation, "⌉");
+ return TRUE;
+ case GDK_e:
+ math_equation_insert_exponent(display->priv->equation);
+ return TRUE;
+ case GDK_f:
+ math_equation_factorize(display->priv->equation);
+ return TRUE;
+ case GDK_i:
+ math_equation_insert(display->priv->equation, "⁻¹");
+ return TRUE;
+ case GDK_p:
+ math_equation_insert(display->priv->equation, "π");
+ return TRUE;
+ case GDK_r:
+ math_equation_insert(display->priv->equation, "√");
+ return TRUE;
+ case GDK_u:
+ math_equation_insert(display->priv->equation, "µ");
+ return TRUE;
+ case GDK_minus:
+ math_equation_insert(display->priv->equation, "⁻");
+ return TRUE;
+ case GDK_apostrophe:
+ math_equation_insert(display->priv->equation, "°");
+ return TRUE;
+ }
+ }
+ if (state == GDK_MOD1_MASK) {
+ switch(event->keyval)
+ {
+ case GDK_bracketleft:
+ math_equation_insert(display->priv->equation, "⌊");
+ return TRUE;
+ case GDK_bracketright:
+ math_equation_insert(display->priv->equation, "⌋");
+ return TRUE;
+ }
+ }
+
+ if (state == GDK_CONTROL_MASK || math_equation_get_number_mode(display->priv->equation) == SUPERSCRIPT) {
+ switch(event->keyval)
+ {
+ case GDK_0:
+ math_equation_insert(display->priv->equation, "⁰");
+ return TRUE;
+ case GDK_1:
+ math_equation_insert(display->priv->equation, "¹");
+ return TRUE;
+ case GDK_2:
+ math_equation_insert(display->priv->equation, "²");
+ return TRUE;
+ case GDK_3:
+ math_equation_insert(display->priv->equation, "³");
+ return TRUE;
+ case GDK_4:
+ math_equation_insert(display->priv->equation, "⁴");
+ return TRUE;
+ case GDK_5:
+ math_equation_insert(display->priv->equation, "⁵");
+ return TRUE;
+ case GDK_6:
+ math_equation_insert(display->priv->equation, "⁶");
+ return TRUE;
+ case GDK_7:
+ math_equation_insert(display->priv->equation, "⁷");
+ return TRUE;
+ case GDK_8:
+ math_equation_insert(display->priv->equation, "⁸");
+ return TRUE;
+ case GDK_9:
+ math_equation_insert(display->priv->equation, "⁹");
+ return TRUE;
+ }
+ }
+ else if (state == GDK_MOD1_MASK || math_equation_get_number_mode(display->priv->equation) == SUBSCRIPT) {
+ switch(event->keyval)
+ {
+ case GDK_0:
+ math_equation_insert(display->priv->equation, "₀");
+ return TRUE;
+ case GDK_1:
+ math_equation_insert(display->priv->equation, "₁");
+ return TRUE;
+ case GDK_2:
+ math_equation_insert(display->priv->equation, "₂");
+ return TRUE;
+ case GDK_3:
+ math_equation_insert(display->priv->equation, "₃");
+ return TRUE;
+ case GDK_4:
+ math_equation_insert(display->priv->equation, "₄");
+ return TRUE;
+ case GDK_5:
+ math_equation_insert(display->priv->equation, "₅");
+ return TRUE;
+ case GDK_6:
+ math_equation_insert(display->priv->equation, "₆");
+ return TRUE;
+ case GDK_7:
+ math_equation_insert(display->priv->equation, "₇");
+ return TRUE;
+ case GDK_8:
+ math_equation_insert(display->priv->equation, "₈");
+ return TRUE;
+ case GDK_9:
+ math_equation_insert(display->priv->equation, "₉");
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+
+static gboolean
+key_press_cb(MathDisplay *display, GdkEventKey *event)
+{
+ gboolean result;
+ g_signal_emit_by_name(display->priv->text_view, "key-press-event", event, &result);
+ return result;
+}
+
+
+static void
+status_changed_cb(MathEquation *equation, GParamSpec *spec, MathDisplay *display)
+{
+ gtk_text_buffer_set_text(display->priv->info_buffer, math_equation_get_status(equation), -1);
+}
+
+
+static void
+create_gui(MathDisplay *display)
+{
+ GtkWidget *info_view;
+ PangoFontDescription *font_desc;
+ 
+ g_signal_connect(display, "key-press-event", G_CALLBACK(key_press_cb), display);
+
+ display->priv->text_view = gtk_text_view_new_with_buffer(GTK_TEXT_BUFFER(display->priv->equation));
+ gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(display->priv->text_view), GTK_WRAP_WORD);
+ gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(display->priv->text_view), FALSE);
+ gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(display->priv->text_view), 8);
+ gtk_text_view_set_pixels_below_lines(GTK_TEXT_VIEW(display->priv->text_view), 2);
+ /* TEMP: Disabled for now as GTK+ doesn't properly render a right aligned right margin, see bug #482688 */
+ /*gtk_text_view_set_right_margin(GTK_TEXT_VIEW(display->priv->text_view), 6);*/
+ gtk_text_view_set_justification(GTK_TEXT_VIEW(display->priv->text_view), GTK_JUSTIFY_RIGHT);
+ gtk_widget_ensure_style(display->priv->text_view);
+ font_desc = pango_font_description_copy(gtk_widget_get_style(display->priv->text_view)->font_desc);
+ pango_font_description_set_size(font_desc, 16 * PANGO_SCALE);
+ gtk_widget_modify_font(display->priv->text_view, font_desc);
+ pango_font_description_free(font_desc);
+ gtk_widget_set_name(display->priv->text_view, "displayitem");
+ atk_object_set_role(gtk_widget_get_accessible(display->priv->text_view), ATK_ROLE_EDITBAR);
+ //FIXME:<property name="AtkObject::accessible-description" translatable="yes" comments="Accessible description for the area in which results are displayed">Result Region</property>
+ g_signal_connect(display->priv->text_view, "key-press-event", G_CALLBACK(display_key_press_cb), display);
+ gtk_box_pack_start(GTK_BOX(display), display->priv->text_view, TRUE, TRUE, 0);
+ 
+ info_view = gtk_text_view_new();
+ gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(info_view), GTK_WRAP_WORD);
+ gtk_widget_set_can_focus(info_view, TRUE); // FIXME: This should be FALSE but it locks the cursor inside the main view for some reason
+ gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(info_view), FALSE); // FIXME: Just here so when incorrectly gets focus doesn't look editable
+ gtk_text_view_set_editable(GTK_TEXT_VIEW(info_view), FALSE);
+ gtk_text_view_set_justification(GTK_TEXT_VIEW(info_view), GTK_JUSTIFY_RIGHT);
+ /* TEMP: Disabled for now as GTK+ doesn't properly render a right aligned right margin, see bug #482688 */
+ /*gtk_text_view_set_right_margin(GTK_TEXT_VIEW(info_view), 6);*/
+ gtk_box_pack_start(GTK_BOX(display), info_view, FALSE, TRUE, 0);
+ display->priv->info_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(info_view));
+
+ gtk_widget_show(info_view);
+ gtk_widget_show(display->priv->text_view);
+
+ g_signal_connect(display->priv->equation, "notify::status", G_CALLBACK(status_changed_cb), display);
+ status_changed_cb(display->priv->equation, NULL, display);
+}
+
+
+static void
+math_display_set_property(GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ MathDisplay *self;
+
+ self = MATH_DISPLAY (object);
+
+ switch (prop_id) {
+ case PROP_EQUATION:
+ self->priv->equation = g_value_get_object (value);
+ create_gui(self);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+
+static void
+math_display_get_property(GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ MathDisplay *self;
+
+ self = MATH_DISPLAY (object);
+
+ switch (prop_id) {
+ case PROP_EQUATION:
+ g_value_set_object (value, self->priv->equation);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+
+static void
+math_display_class_init (MathDisplayClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->get_property = math_display_get_property;
+ object_class->set_property = math_display_set_property;
+
+ g_type_class_add_private (klass, sizeof (MathDisplayPrivate));
+
+ g_object_class_install_property(object_class,
+ PROP_EQUATION,
+ g_param_spec_object("equation",
+ "equation",
+ "Equation being displayed",
+ math_equation_get_type(),
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+}
+
+
+static void 
+math_display_init(MathDisplay *display)
+{
+ display->priv = G_TYPE_INSTANCE_GET_PRIVATE (display, math_display_get_type(), MathDisplayPrivate);
+}
diff --git a/src/math-display.h b/src/math-display.h
new file mode 100644
index 0000000..f933d37
--- /dev/null
+++ b/src/math-display.h
@@ -0,0 +1,52 @@
+/* Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef MATH_DISPLAY_H
+#define MATH_DISPLAY_H
+
+#include <glib-object.h>
+#include <gtk/gtk.h>
+
+#include "math-equation.h"
+
+G_BEGIN_DECLS
+
+#define MATH_DISPLAY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), math_display_get_type(), MathDisplay))
+
+typedef struct MathDisplayPrivate MathDisplayPrivate;
+
+typedef struct
+{
+ GtkVBox parent_instance;
+ MathDisplayPrivate *priv;
+} MathDisplay;
+
+typedef struct
+{
+ GtkVBoxClass parent_class;
+} MathDisplayClass;
+
+GType math_display_get_type(void);
+
+MathDisplay *math_display_new(void);
+
+MathDisplay *math_display_new_with_equation(MathEquation *equation);
+
+MathEquation *math_display_get_equation(MathDisplay *display);
+
+#endif /* MATH_DISPLAY_H */
diff --git a/src/math-equation.c b/src/math-equation.c
new file mode 100644
index 0000000..af68cd1
--- /dev/null
+++ b/src/math-equation.c
@@ -0,0 +1,1701 @@
+/* Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+#include <errno.h>
+#include <glib.h>
+#include <langinfo.h>
+#include <locale.h>
+
+#include "math-equation.h"
+
+#include "mp.h"
+#include "mp-equation.h"
+#include "currency.h"
+
+
+enum {
+ PROP_0,
+ PROP_STATUS,
+ PROP_DISPLAY,
+ PROP_EQUATION,
+ PROP_NUMBER_MODE,
+ PROP_ACCURACY,
+ PROP_SHOW_THOUSANDS_SEPARATORS,
+ PROP_SHOW_TRAILING_ZEROES,
+ PROP_NUMBER_FORMAT,
+ PROP_BASE,
+ PROP_WORD_SIZE,
+ PROP_ANGLE_UNITS,
+ PROP_SOURCE_CURRENCY,
+ PROP_TARGET_CURRENCY
+};
+
+static GType number_mode_type, number_format_type, angle_unit_type;
+
+#define MAX_DIGITS 512
+
+/* Expression mode state */
+typedef struct {
+ MPNumber ans; /* Previously calculated answer */
+ gchar *expression; /* Expression entered by user */
+ gint ans_start, ans_end; /* Start and end characters for ans variable in expression */
+ gint cursor; /* ??? */
+ NumberMode number_mode; /* ??? */
+ gboolean can_super_minus; /* TRUE if entering minus can generate a superscript minus */
+ gboolean entered_multiply; /* Last insert was a multiply character */
+ gchar *status; /* Equation status */
+} MathEquationState;
+
+struct MathEquationPrivate
+{
+ GtkTextTag *ans_tag;
+
+ gint show_tsep; /* Set if the thousands separator should be shown. */
+ gint show_zeroes; /* Set if trailing zeroes should be shown. */
+ DisplayFormat format; /* Number display mode. */
+ gint accuracy; /* Number of digits to show */
+ gint word_size; /* Word size in bits */
+ MPAngleUnit angle_units; /* Units for trigonometric functions */
+ char *source_currency;
+ char *target_currency;
+ gint base; /* Numeric base */
+ NumberMode number_mode; /* ??? */
+ gboolean can_super_minus; /* TRUE if entering minus can generate a superscript minus */
+
+ const char *digits[16]; /* Localized digit values */
+ const char *radix; /* Locale specific radix string. */
+ const char *tsep; /* Locale specific thousands separator. */
+ gint tsep_count; /* Number of digits between separator. */
+
+ GtkTextMark *ans_start, *ans_end;
+
+ MathEquationState state; /* Equation state */
+ GList *undo_stack; /* History of expression mode states */
+ GList *redo_stack;
+ gboolean in_undo_operation;
+ 
+ gboolean in_reformat;
+
+ gboolean in_delete;
+
+ MathVariables *variables;
+};
+
+G_DEFINE_TYPE (MathEquation, math_equation, GTK_TYPE_TEXT_BUFFER);
+
+
+MathEquation *
+math_equation_new()
+{
+ return g_object_new (math_equation_get_type(), NULL);
+}
+
+
+MathVariables *
+math_equation_get_variables(MathEquation *equation)
+{
+ return equation->priv->variables;
+}
+
+
+static void
+get_ans_offsets(MathEquation *equation, gint *start, gint *end)
+{
+ GtkTextIter iter;
+ 
+ if (!equation->priv->ans_start) {
+ *start = *end = -1;
+ return;
+ }
+
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &iter, equation->priv->ans_start);
+ *start = gtk_text_iter_get_offset(&iter);
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &iter, equation->priv->ans_end);
+ *end = gtk_text_iter_get_offset(&iter);
+}
+
+
+static void
+reformat_ans(MathEquation *equation)
+{
+ if (!equation->priv->ans_start)
+ return;
+
+ gchar *orig_ans_text;
+ gchar ans_text[MAX_DIGITS];
+ GtkTextIter ans_start, ans_end;
+
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &ans_start, equation->priv->ans_start);
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &ans_end, equation->priv->ans_end);
+ orig_ans_text = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(equation), &ans_start, &ans_end, FALSE);
+ display_make_number(equation, ans_text, MAX_DIGITS, &equation->priv->state.ans);
+ if (strcmp(orig_ans_text, ans_text) != 0) {
+ gint start;
+
+ equation->priv->in_undo_operation = TRUE;
+ equation->priv->in_reformat = TRUE;
+
+ start = gtk_text_iter_get_offset(&ans_start);
+ gtk_text_buffer_delete(GTK_TEXT_BUFFER(equation), &ans_start, &ans_end);
+ gtk_text_buffer_insert_with_tags(GTK_TEXT_BUFFER(equation), &ans_end, ans_text, -1, equation->priv->ans_tag, NULL);
+
+ /* There seems to be a bug in the marks as they alternate being the correct and incorrect ways. Reset them */
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &ans_start, start);
+ gtk_text_buffer_move_mark(GTK_TEXT_BUFFER(equation), equation->priv->ans_start, &ans_start);
+ gtk_text_buffer_move_mark(GTK_TEXT_BUFFER(equation), equation->priv->ans_end, &ans_end);
+
+ equation->priv->in_reformat = FALSE;
+ equation->priv->in_undo_operation = FALSE;
+ }
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &ans_start, equation->priv->ans_start);
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &ans_end, equation->priv->ans_end);
+ g_free(orig_ans_text);
+}
+
+
+/* NOTE: Not efficent but easy to write */
+// FIXME: This is just a lexer - use the same lexer as the solver
+static void
+reformat_base(MathEquation *equation, gint old_base)
+{
+ gunichar sub_zero, sub_nine;
+ gchar *text, *read_iter;
+ gboolean in_number = FALSE, have_radix = FALSE;
+ gint offset = 0, offset_step = 0, max_digit = 0, base = -1, base_offset = 0;
+ gint ans_start, ans_end;
+
+ if (equation->priv->base == old_base)
+ return;
+
+ sub_zero = g_utf8_get_char("₀");
+ sub_nine = g_utf8_get_char("₉");
+
+ read_iter = text = math_equation_get_display(equation);
+ get_ans_offsets(equation, &ans_start, &ans_end);
+ while (TRUE) {
+ gunichar c;
+ gint digit = -1, sub_digit = -1;
+
+ /* See what digit this character is */
+ c = g_utf8_get_char(read_iter);
+ if (c >= sub_zero && c <= sub_nine)
+ sub_digit = c - sub_zero;
+ else if (c >= 'a' && c <= 'z')
+ digit = c - 'a';
+ else if (c >= 'A' && c <= 'Z')
+ digit = c - 'A';
+ else
+ digit = g_unichar_digit_value(c);
+
+ /* Don't mess with ans */
+ if (offset >= ans_start && offset <= ans_end) {
+ digit = -1;
+ sub_digit = -1;
+ }
+
+ if (in_number && digit >= 0) {
+ if (digit > max_digit)
+ max_digit = digit;
+ }
+ else if (in_number && sub_digit >= 0) {
+ if (base < 0) {
+ base_offset = offset;
+ base = 0;
+ }
+
+ base = base * 10 + sub_digit;
+ }
+ else if (in_number) {
+ /* Allow one radix inside a number */
+ if (!have_radix && base < 0 && strncmp(read_iter, equation->priv->radix, strlen(equation->priv->radix)) == 0) {
+ have_radix = TRUE;
+ read_iter += strlen(equation->priv->radix);
+ offset += g_utf8_strlen(equation->priv->radix, -1);
+ continue;
+ }
+
+ /* If had no base then insert it */
+ if (base < 0) {
+ GtkTextIter iter;
+ gint multiplier = 1;
+ gint b = old_base;
+ const char *digits[] = {"₀", "₁", "₂", "₃", "₄", "₅", "₆", "₇", "₈", "₉"};
+
+ equation->priv->in_undo_operation = TRUE;
+ equation->priv->in_reformat = TRUE;
+
+ while (b / multiplier != 0)
+ multiplier *= 10;
+ while (multiplier != 1) {
+ int d;
+ multiplier /= 10;
+ d = b / multiplier;
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &iter, offset + offset_step);
+ gtk_text_buffer_insert(GTK_TEXT_BUFFER(equation), &iter, digits[d], -1);
+ offset_step++;
+ b -= d * multiplier;
+ }
+
+ equation->priv->in_reformat = FALSE;
+ equation->priv->in_undo_operation = FALSE;
+ }
+ /* Remove the base if the current value */
+ else if (max_digit < base && base == equation->priv->base) {
+ GtkTextIter start, end;
+
+ equation->priv->in_undo_operation = TRUE;
+ equation->priv->in_reformat = TRUE;
+
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &start, base_offset + offset_step);
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &end, offset + offset_step);
+ gtk_text_buffer_delete(GTK_TEXT_BUFFER(equation), &start, &end);
+ offset_step -= offset - base_offset;
+
+ equation->priv->in_reformat = FALSE;
+ equation->priv->in_undo_operation = FALSE;
+ }
+
+ in_number = FALSE;
+ }
+ else if (digit >= 0) {
+ in_number = TRUE;
+ have_radix = FALSE;
+ base = -1;
+ max_digit = digit;
+ }
+
+ if (c == '\0')
+ break;
+ 
+ read_iter = g_utf8_next_char(read_iter);
+ offset++;
+ }
+
+ g_free(text);
+}
+
+
+static void
+reformat_separators(MathEquation *equation)
+{
+#if 0
+ gchar *text, *read_iter;
+ gboolean in_number = FALSE, in_fraction = FALSE;
+
+ text = math_equation_get_display(equation);
+
+ /* Find numbers in display, and modify if necessary */
+ read_iter = text;
+ while(*read_iter != '\0') {
+ gunichar c;
+ 
+ c = g_utf8_get_char(read_iter);
+
+ if (strncmp(read_iter, equation->priv->tsep, strlen(equation->priv->tsep)) == 0)
+ ;
+ read_iter = g_utf8_next_char(read_iter);
+ }
+
+ g_free(text);
+#endif
+}
+
+
+static void
+reformat_display(MathEquation *equation, gint old_base)
+{
+ /* Change ans */
+ reformat_ans(equation);
+
+ /* Add/remove base suffixes if have changed base */
+ reformat_base(equation, old_base);
+
+ /* Add/remove thousands separators */
+ reformat_separators(equation);
+}
+
+
+static MathEquationState *
+get_current_state(MathEquation *equation)
+{
+ MathEquationState *state;
+ gint ans_start = -1, ans_end = -1;
+
+ state = g_malloc0(sizeof(MathEquationState));
+
+ if (equation->priv->ans_start)
+ {
+ GtkTextIter iter;
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &iter, equation->priv->ans_start);
+ ans_start = gtk_text_iter_get_offset(&iter);
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &iter, equation->priv->ans_end);
+ ans_end = gtk_text_iter_get_offset(&iter);
+ }
+
+ mp_set_from_mp(&equation->priv->state.ans, &state->ans);
+ state->expression = math_equation_get_display(equation);
+ state->ans_start = ans_start;
+ state->ans_end = ans_end;
+ g_object_get(G_OBJECT(equation), "cursor-position", &state->cursor, NULL);
+ state->number_mode = equation->priv->number_mode;
+ state->can_super_minus = equation->priv->can_super_minus;
+ state->entered_multiply = equation->priv->state.entered_multiply;
+ state->status = g_strdup(equation->priv->state.status);
+ 
+ return state;
+}
+
+
+static void
+free_state(MathEquationState *state)
+{
+ g_free(state->expression);
+ g_free(state->status);
+ g_free(state);
+}
+
+
+static void
+math_equation_push_undo_stack(MathEquation *equation)
+{
+ GList *link;
+ MathEquationState *state;
+
+ if (equation->priv->in_undo_operation)
+ return;
+
+ math_equation_set_status(equation, "");
+
+ /* Can't redo anymore */
+ for (link = equation->priv->redo_stack; link; link = link->next) {
+ state = link->data;
+ free_state(state);
+ }
+ g_list_free(equation->priv->redo_stack);
+ equation->priv->redo_stack = NULL;
+
+ state = get_current_state(equation);
+ equation->priv->undo_stack = g_list_prepend(equation->priv->undo_stack, state); 
+}
+
+
+static void
+clear_ans(MathEquation *equation, gboolean remove_tag)
+{
+ if (!equation->priv->ans_start)
+ return;
+
+ if (remove_tag) {
+ GtkTextIter start, end;
+
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &start, equation->priv->ans_start);
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &end, equation->priv->ans_end);
+ gtk_text_buffer_remove_tag(GTK_TEXT_BUFFER(equation), equation->priv->ans_tag, &start, &end);
+ }
+
+ gtk_text_buffer_delete_mark(GTK_TEXT_BUFFER(equation), equation->priv->ans_start);
+ gtk_text_buffer_delete_mark(GTK_TEXT_BUFFER(equation), equation->priv->ans_end);
+ equation->priv->ans_start = NULL;
+ equation->priv->ans_end = NULL;
+}
+
+
+static void
+apply_state(MathEquation *equation, MathEquationState *state)
+{
+ GtkTextIter cursor;
+ 
+ /* Disable undo detection */
+ equation->priv->in_undo_operation = TRUE;
+
+ mp_set_from_mp(&state->ans, &equation->priv->state.ans);
+
+ gtk_text_buffer_set_text(GTK_TEXT_BUFFER(equation), state->expression, -1);
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &cursor, state->cursor);
+ gtk_text_buffer_place_cursor(GTK_TEXT_BUFFER(equation), &cursor);
+ clear_ans(equation, FALSE);
+ if (state->ans_start >= 0) {
+ GtkTextIter start, end;
+
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &start, state->ans_start);
+ equation->priv->ans_start = gtk_text_buffer_create_mark(GTK_TEXT_BUFFER(equation), NULL, &start, FALSE);
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &end, state->ans_end);
+ equation->priv->ans_end = gtk_text_buffer_create_mark(GTK_TEXT_BUFFER(equation), NULL, &end, TRUE);
+ gtk_text_buffer_apply_tag(GTK_TEXT_BUFFER(equation), equation->priv->ans_tag, &start, &end);
+ }
+
+ math_equation_set_number_mode(equation, state->number_mode);
+ equation->priv->can_super_minus = state->can_super_minus;
+ equation->priv->state.entered_multiply = state->entered_multiply;
+ math_equation_set_status(equation, state->status);
+
+ equation->priv->in_undo_operation = FALSE;
+}
+
+
+void
+math_equation_copy(MathEquation *equation)
+{
+ GtkTextIter start, end;
+ gchar *text;
+
+ if (!gtk_text_buffer_get_selection_bounds(GTK_TEXT_BUFFER(equation), &start, &end))
+ gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(equation), &start, &end);
+
+ text = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(equation), &start, &end, FALSE);
+ gtk_clipboard_set_text(gtk_clipboard_get(GDK_NONE), text, -1);
+ g_free (text);
+}
+
+
+static void
+on_paste(GtkClipboard *clipboard, const gchar *text, gpointer data)
+{
+ MathEquation *equation = data;
+ math_equation_insert (equation, text);
+}
+
+
+void
+math_equation_paste(MathEquation *equation)
+{
+ gtk_clipboard_request_text(gtk_clipboard_get(GDK_NONE), on_paste, equation);
+}
+
+
+void
+math_equation_undo(MathEquation *equation)
+{
+ GList *link;
+ MathEquationState *state;
+ 
+ if (!equation->priv->undo_stack) {
+ math_equation_set_status(equation,
+ /* Error shown when trying to undo with no undo history */
+ _("No undo history"));
+ return;
+ }
+
+ link = equation->priv->undo_stack;
+ equation->priv->undo_stack = g_list_remove_link(equation->priv->undo_stack, link);
+ state = link->data;
+ g_list_free(link);
+
+ equation->priv->redo_stack = g_list_prepend(equation->priv->redo_stack, get_current_state(equation));
+
+ apply_state(equation, state);
+ free_state(state);
+}
+
+
+void
+math_equation_redo(MathEquation *equation)
+{
+ GList *link;
+ MathEquationState *state;
+
+ if (!equation->priv->redo_stack) {
+ math_equation_set_status(equation,
+ /* Error shown when trying to redo with no redo history */
+ _("No redo history"));
+ return;
+ }
+
+ link = equation->priv->redo_stack;
+ equation->priv->redo_stack = g_list_remove_link(equation->priv->redo_stack, link);
+ state = link->data;
+ g_list_free(link);
+
+ equation->priv->undo_stack = g_list_prepend(equation->priv->undo_stack, get_current_state(equation));
+
+ apply_state(equation, state);
+ free_state(state);
+}
+
+
+const gchar *
+math_equation_get_digit_text(MathEquation *equation, guint digit)
+{
+ return equation->priv->digits[digit];
+}
+
+
+const gchar *
+math_equation_get_numeric_point_text(MathEquation *equation)
+{
+ return equation->priv->radix;
+}
+
+
+const gchar *math_equation_get_thousands_separator_text(MathEquation *equation)
+{
+ return equation->priv->tsep;
+}
+
+
+void
+math_equation_set_accuracy(MathEquation *equation, gint accuracy)
+{
+ if (equation->priv->accuracy == accuracy)
+ return;
+ equation->priv->accuracy = accuracy;
+ reformat_display(equation, equation->priv->base);
+ g_object_notify(G_OBJECT(equation), "accuracy");
+}
+
+
+gint
+math_equation_get_accuracy(MathEquation *equation)
+{
+ return equation->priv->accuracy;
+}
+
+
+void
+math_equation_set_show_thousands_separators(MathEquation *equation, gboolean visible)
+{
+ if ((equation->priv->show_tsep && visible) || (!equation->priv->show_tsep && !visible))
+ return;
+ equation->priv->show_tsep = visible;
+ reformat_display(equation, equation->priv->base);
+ g_object_notify(G_OBJECT(equation), "show-thousands-separators");
+}
+
+
+gboolean
+math_equation_get_show_thousands_separators(MathEquation *equation)
+{
+ return equation->priv->show_tsep;
+}
+
+
+void
+math_equation_set_show_trailing_zeroes(MathEquation *equation, gboolean visible)
+{
+ if ((equation->priv->show_zeroes && visible) || (!equation->priv->show_zeroes && !visible))
+ return;
+ equation->priv->show_zeroes = visible;
+ reformat_display(equation, equation->priv->base);
+ g_object_notify(G_OBJECT(equation), "show-trailing-zeroes");
+}
+
+
+gboolean
+math_equation_get_show_trailing_zeroes(MathEquation *equation)
+{
+ return equation->priv->show_zeroes;
+}
+
+
+void
+math_equation_set_number_format(MathEquation *equation, DisplayFormat format)
+{
+ if (equation->priv->format == format)
+ return;
+
+ equation->priv->format = format;
+ reformat_display(equation, equation->priv->base);
+ g_object_notify(G_OBJECT(equation), "number-format");
+}
+
+
+DisplayFormat
+math_equation_get_number_format(MathEquation *equation)
+{
+ return equation->priv->format;
+}
+
+
+void
+math_equation_set_base(MathEquation *equation, gint base)
+{
+ gint old_base;
+
+ if (equation->priv->base == base)
+ return;
+
+ old_base = equation->priv->base;
+ equation->priv->base = base;
+ reformat_display(equation, old_base);
+ g_object_notify(G_OBJECT(equation), "base");
+}
+
+
+gint
+math_equation_get_base(MathEquation *equation)
+{
+ return equation->priv->base;
+}
+
+
+void
+math_equation_set_word_size(MathEquation *equation, gint word_size)
+{
+ if (equation->priv->word_size == word_size)
+ return;
+ equation->priv->word_size = word_size;
+ g_object_notify(G_OBJECT(equation), "word-size");
+}
+
+
+gint
+math_equation_get_word_size(MathEquation *equation)
+{
+ return equation->priv->word_size;
+}
+
+
+void
+math_equation_set_angle_units(MathEquation *equation, MPAngleUnit angle_units)
+{
+ if (equation->priv->angle_units == angle_units)
+ return;
+ equation->priv->angle_units = angle_units;
+ g_object_notify(G_OBJECT(equation), "angle-units");
+}
+
+
+MPAngleUnit
+math_equation_get_angle_units(MathEquation *equation)
+{
+ return equation->priv->angle_units;
+}
+
+
+void
+math_equation_set_source_currency(MathEquation *equation, const gchar *currency)
+{
+ // FIXME: Pick based on locale 
+ if (!currency || currency[0] == '\0')
+ currency = currency_names[0].short_name;
+
+ if (strcmp(equation->priv->source_currency, currency) == 0)
+ return;
+ g_free(equation->priv->source_currency);
+ equation->priv->source_currency = g_strdup(currency);
+ g_object_notify(G_OBJECT(equation), "source-currency");
+}
+
+const gchar *
+math_equation_get_source_currency(MathEquation *equation)
+{
+ return equation->priv->source_currency;
+}
+
+
+void
+math_equation_set_target_currency(MathEquation *equation, const gchar *currency)
+{
+ // FIXME: Pick based on locale 
+ if (!currency || currency[0] == '\0')
+ currency = currency_names[0].short_name;
+
+ if (strcmp(equation->priv->target_currency, currency) == 0)
+ return;
+ g_free(equation->priv->target_currency);
+ equation->priv->target_currency = g_strdup(currency);
+ g_object_notify(G_OBJECT(equation), "target-currency");
+}
+
+
+const gchar *
+math_equation_get_target_currency(MathEquation *equation)
+{
+ return equation->priv->target_currency;
+}
+
+
+void
+math_equation_set_status(MathEquation *equation, const gchar *status)
+{
+ if (strcmp(equation->priv->state.status, status) == 0)
+ return;
+
+ g_free(equation->priv->state.status);
+ equation->priv->state.status = g_strdup(status);
+ g_object_notify(G_OBJECT(equation), "status"); 
+}
+
+
+const gchar *
+math_equation_get_status(MathEquation *equation)
+{
+ return equation->priv->state.status;
+}
+
+
+gboolean
+math_equation_is_empty(MathEquation *equation)
+{
+ return gtk_text_buffer_get_char_count(GTK_TEXT_BUFFER(equation)) == 0;
+}
+
+
+gboolean
+math_equation_is_result(MathEquation *equation)
+{
+ char *text;
+ gboolean result;
+
+ text = math_equation_get_equation(equation);
+ result = strcmp(text, "ans") == 0;
+ g_free(text);
+
+ return result;
+}
+
+
+gchar *
+math_equation_get_display(MathEquation *equation)
+{
+ GtkTextIter start, end;
+
+ gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(equation), &start, &end);
+ return gtk_text_buffer_get_text(GTK_TEXT_BUFFER(equation), &start, &end, FALSE);
+}
+
+
+gchar *
+math_equation_get_equation(MathEquation *equation)
+{
+ char *text, *t;
+ gint ans_start, ans_end;
+
+ text = math_equation_get_display(equation);
+
+ /* No ans to substitute */
+ if(!equation->priv->ans_start)
+ return text;
+
+ get_ans_offsets(equation, &ans_start, &ans_end);
+ t = g_strdup_printf("%.*sans%s", (int)(g_utf8_offset_to_pointer(text, ans_start) - text), text, g_utf8_offset_to_pointer(text, ans_end));
+ g_free(text);
+ return t;
+}
+
+
+gboolean
+math_equation_get_number(MathEquation *equation, MPNumber *z)
+{
+ gchar *text;
+ gboolean result;
+
+ text = math_equation_get_display(equation);
+ result = !mp_set_from_string(text, equation->priv->base, z);
+ g_free (text);
+
+ return result;
+}
+
+
+void
+math_equation_set_number_mode(MathEquation *equation, NumberMode mode)
+{
+ if (equation->priv->number_mode == mode)
+ return;
+
+ equation->priv->can_super_minus = mode == SUPERSCRIPT;
+
+ equation->priv->number_mode = mode;
+ g_object_notify(G_OBJECT(equation), "number-mode");
+}
+
+
+NumberMode
+math_equation_get_number_mode(MathEquation *equation)
+{
+ return equation->priv->number_mode;
+}
+
+
+const MPNumber *
+math_equation_get_answer(MathEquation *equation)
+{
+ return &equation->priv->state.ans;
+}
+
+
+void
+math_equation_store(MathEquation *equation, const gchar *name)
+{
+ MPNumber t;
+
+ if (!math_equation_get_number(equation, &t))
+ math_equation_set_status(equation, _("No sane value to store"));
+ else
+ math_variables_set_value(equation->priv->variables, name, &t);
+}
+
+
+void
+math_equation_recall(MathEquation *equation, const gchar *name)
+{
+ math_equation_insert(equation, name);
+}
+
+
+void
+math_equation_set(MathEquation *equation, const gchar *text)
+
+{
+ gtk_text_buffer_set_text(GTK_TEXT_BUFFER(equation), text, -1);
+ clear_ans(equation, FALSE);
+}
+
+
+void
+math_equation_set_number(MathEquation *equation, const MPNumber *x)
+{
+ char text[MAX_DIGITS];
+ GtkTextIter start, end;
+
+ /* Show the number in the user chosen format */
+ display_make_number(equation, text, MAX_DIGITS, x);
+ gtk_text_buffer_set_text(GTK_TEXT_BUFFER(equation), text, -1);
+ mp_set_from_mp(x, &equation->priv->state.ans);
+
+ /* Mark this text as the answer variable */
+ gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(equation), &start, &end);
+ clear_ans(equation, FALSE);
+ equation->priv->ans_start = gtk_text_buffer_create_mark(GTK_TEXT_BUFFER(equation), NULL, &start, FALSE);
+ equation->priv->ans_end = gtk_text_buffer_create_mark(GTK_TEXT_BUFFER(equation), NULL, &end, TRUE);
+ gtk_text_buffer_apply_tag(GTK_TEXT_BUFFER(equation), equation->priv->ans_tag, &start, &end);
+}
+
+
+void
+math_equation_insert(MathEquation *equation, const gchar *text)
+{
+ /* Replace ** with ^ (not on all keyboards) */
+ if (!gtk_text_buffer_get_has_selection(GTK_TEXT_BUFFER(equation)) &&
+ strcmp(text, "×") == 0 && equation->priv->state.entered_multiply) {
+ GtkTextIter iter;
+
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &iter, gtk_text_buffer_get_insert(GTK_TEXT_BUFFER(equation)));
+ gtk_text_buffer_backspace(GTK_TEXT_BUFFER(equation), &iter, TRUE, TRUE);
+ gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(equation), "^", -1);
+ return;
+ }
+
+ /* Start new equation when entering digits after existing result */
+ if(math_equation_is_result(equation) && g_unichar_isdigit(g_utf8_get_char(text)))
+ gtk_text_buffer_set_text(GTK_TEXT_BUFFER(equation), "", -1);
+
+ /* Can't enter superscript minus after entering digits */
+ if (strstr("⁰¹²³⁴⁵⁶⁷⁸⁹", text) != NULL || strcmp("⁻", text) == 0)
+ equation->priv->can_super_minus = FALSE;
+
+ /* Disable super/subscript mode when finished entering */
+ if (strstr("⁻⁰¹²³⁴⁵⁶⁷⁸⁹₀₁₂₃₄₅₆₇₈₉", text) == NULL)
+ math_equation_set_number_mode(equation, NORMAL);
+
+ // FIXME: Add thousands separators
+
+ gtk_text_buffer_delete_selection(GTK_TEXT_BUFFER(equation), FALSE, FALSE);
+ gtk_text_buffer_insert_at_cursor(GTK_TEXT_BUFFER(equation), text, -1);
+}
+
+
+void
+math_equation_insert_digit(MathEquation *equation, guint digit)
+{
+ static const char *subscript_digits[] = {"₀", "₁", "₂", "₃", "₄", "₅", "₆", "₇", "₈", "₉", NULL};
+ static const char *superscript_digits[] = {"⁰", "¹", "²", "³", "⁴", "⁵", "⁶", "⁷", "⁸", "⁹", NULL};
+
+ if (equation->priv->number_mode == NORMAL || digit >= 10)
+ math_equation_insert(equation, math_equation_get_digit_text(equation, digit));
+ else if (equation->priv->number_mode == SUPERSCRIPT)
+ math_equation_insert(equation, superscript_digits[digit]);
+ else if (equation->priv->number_mode == SUBSCRIPT)
+ math_equation_insert(equation, subscript_digits[digit]);
+}
+
+
+void
+math_equation_insert_numeric_point(MathEquation *equation)
+{
+ math_equation_insert(equation, math_equation_get_numeric_point_text(equation));
+}
+
+
+void
+math_equation_insert_number(MathEquation *equation, const MPNumber *x)
+{
+ char text[MAX_DIGITS];
+ display_make_number(equation, text, MAX_DIGITS, x);
+ math_equation_insert(equation, text);
+}
+
+
+void
+math_equation_insert_exponent(MathEquation *equation)
+{
+ math_equation_insert(equation, "×10");
+ math_equation_set_number_mode(equation, SUPERSCRIPT);
+}
+
+
+void
+math_equation_insert_subtract(MathEquation *equation)
+{
+ if (equation->priv->number_mode == SUPERSCRIPT && equation->priv->can_super_minus) {
+ math_equation_insert(equation, "⁻");
+ equation->priv->can_super_minus = FALSE;
+ }
+ else {
+ math_equation_insert(equation, "−");
+ math_equation_set_number_mode(equation, NORMAL);
+ }
+}
+
+
+static int
+variable_is_defined(const char *name, void *data)
+{
+ MathEquation *equation = data;
+ char *c, *lower_name;
+
+ lower_name = strdup(name);
+ for (c = lower_name; *c; c++)
+ *c = tolower(*c);
+
+ if (strcmp(lower_name, "rand") == 0 || 
+ strcmp(lower_name, "ans") == 0) {
+ g_free (lower_name);
+ return 1;
+ }
+ g_free (lower_name);
+
+ return math_variables_get_value(equation->priv->variables, name) != NULL;
+}
+
+
+static int
+get_variable(const char *name, MPNumber *z, void *data)
+{
+ char *c, *lower_name;
+ int result = 1;
+ MathEquation *equation = data;
+ MPNumber *t;
+
+ lower_name = strdup(name);
+ for (c = lower_name; *c; c++)
+ *c = tolower(*c);
+
+ if (strcmp(lower_name, "rand") == 0)
+ mp_set_from_random(z);
+ else if (strcmp(lower_name, "ans") == 0)
+ mp_set_from_mp(&equation->priv->state.ans, z);
+ else {
+ t = math_variables_get_value(equation->priv->variables, name);
+ if (t)
+ mp_set_from_mp(t, z);
+ else
+ result = 0;
+ }
+
+ free(lower_name);
+
+ return result;
+}
+
+
+static void
+set_variable(const char *name, const MPNumber *x, void *data)
+{
+ MathEquation *equation = data;
+ /* FIXME: Don't allow writing to built-in variables, e.g. ans, rand, sin, ... */
+ math_variables_set_value(equation->priv->variables, name, x);
+}
+
+
+static int
+convert(const MPNumber *x, const char *x_units, const char *z_units, MPNumber *z, void *data)
+{ 
+ return currency_convert(x, x_units, z_units, z);
+}
+
+
+static int
+parse(MathEquation *equation, const char *text, MPNumber *z, char **error_token)
+{
+ MPEquationOptions options;
+
+ memset(&options, 0, sizeof(options));
+ options.base = equation->priv->base;
+ options.wordlen = equation->priv->word_size;
+ options.angle_units = equation->priv->angle_units;
+ options.variable_is_defined = variable_is_defined;
+ options.get_variable = get_variable;
+ options.set_variable = set_variable;
+ options.convert = convert;
+ options.callback_data = equation;
+
+ return mp_equation_parse(text, &options, z, error_token);
+}
+
+
+void
+math_equation_solve(MathEquation *equation)
+{
+ MPNumber z;
+ gint result, n_brackets = 0;
+ gchar *c, *text, *error_token = NULL, *message = NULL;
+ GString *equation_text;
+
+ if (math_equation_is_empty(equation))
+ return;
+
+ /* If showing a result return to the equation that caused it */
+ // FIXME: Result may not be here due to solve (i.e. the user may have entered "ans")
+ if (math_equation_is_result(equation)) {
+ math_equation_undo(equation);
+ return;
+ }
+
+ math_equation_set_number_mode(equation, NORMAL);
+
+ text = math_equation_get_equation(equation);
+ equation_text = g_string_new(text);
+ g_free(text);
+ /* Count the number of brackets and automatically add missing closing brackets */
+ for (c = equation_text->str; *c; c++) {
+ if (*c == '(')
+ n_brackets++;
+ else if (*c == ')')
+ n_brackets--;
+ }
+ while (n_brackets > 0) {
+ g_string_append_c(equation_text, ')');
+ n_brackets--;
+ }
+ 
+
+ result = parse(equation, equation_text->str, &z, &error_token);
+ g_string_free(equation_text, TRUE);
+
+ switch (result) {
+ case PARSER_ERR_NONE:
+ math_equation_set_number(equation, &z);
+ break;
+
+ case PARSER_ERR_OVERFLOW:
+ message = g_strdup(/* Error displayed to user when they perform a bitwise operation on numbers greater than the current word */
+ _("Overflow. Try a bigger word size"));
+ break;
+
+ case PARSER_ERR_UNKNOWN_VARIABLE:
+ message = g_strdup_printf(/* Error displayed to user when they an unknown variable is entered */
+ _("Unknown variable '%s'"), error_token);
+ break;
+
+ case PARSER_ERR_UNKNOWN_FUNCTION:
+ message = g_strdup_printf(/* Error displayed to user when an unknown function is entered */
+ _("Function '%s' is not defined"), error_token);
+ break;
+
+ case PARSER_ERR_UNKNOWN_CONVERSION:
+ message = g_strdup(/* Error displayed to user when an conversion with unknown units is attempted */
+ _("Unknown conversion"));
+ break;
+
+ case PARSER_ERR_MP:
+ message = g_strdup(mp_get_error());
+ break;
+
+ default:
+ message = g_strdup(/* Error displayed to user when they enter an invalid calculation */
+ _("Malformed expression"));
+ break;
+ }
+
+ if (error_token)
+ free(error_token);
+ 
+ if (message) {
+ math_equation_set_status(equation, message);
+ g_free(message);
+ }
+}
+
+
+void
+math_equation_factorize(MathEquation *equation)
+{
+ MPNumber x;
+ GList *factors, *factor;
+ GString *text;
+ 
+ if (!math_equation_get_number(equation, &x) || !mp_is_integer(&x)) {
+ /* Error displayed when trying to factorize a non-integer value */
+ math_equation_set_status(equation, _("Need an integer to factorize"));
+ return;
+ }
+
+ factors = mp_factorize(&x);
+
+ text = g_string_new("");
+
+ for (factor = factors; factor; factor = factor->next) {
+ gchar temp[MAX_DIGITS];
+ MPNumber *n;
+
+ n = factor->data;
+ display_make_number(equation, temp, MAX_DIGITS, n);
+ g_string_append(text, temp);
+ if (factor->next)
+ g_string_append(text, "×");
+ g_slice_free(MPNumber, n);
+ }
+ g_list_free(factors);
+
+ math_equation_set(equation, text->str);
+ g_string_free(text, TRUE);
+}
+
+
+void
+math_equation_delete(MathEquation *equation)
+{
+ gint cursor;
+ GtkTextIter start, end; 
+
+ g_object_get(G_OBJECT(equation), "cursor-position", &cursor, NULL);
+ if (cursor >= gtk_text_buffer_get_char_count(GTK_TEXT_BUFFER(equation)))
+ return;
+
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &start, cursor);
+ gtk_text_buffer_get_iter_at_offset(GTK_TEXT_BUFFER(equation), &end, cursor+1);
+ gtk_text_buffer_delete(GTK_TEXT_BUFFER(equation), &start, &end);
+}
+
+
+void
+math_equation_backspace(MathEquation *equation)
+{
+ /* Can't delete empty display */
+ if (math_equation_is_empty(equation))
+ return;
+
+ if (gtk_text_buffer_get_has_selection(GTK_TEXT_BUFFER(equation)))
+ gtk_text_buffer_delete_selection(GTK_TEXT_BUFFER(equation), FALSE, FALSE);
+ else {
+ GtkTextIter iter;
+ gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(equation), &iter, gtk_text_buffer_get_insert(GTK_TEXT_BUFFER(equation)));
+ gtk_text_buffer_backspace(GTK_TEXT_BUFFER(equation), &iter, TRUE, TRUE);
+ }
+}
+
+
+void
+math_equation_clear(MathEquation *equation)
+{
+ math_equation_set_number_mode(equation, NORMAL);
+ gtk_text_buffer_set_text(GTK_TEXT_BUFFER(equation), "", -1);
+ clear_ans(equation, FALSE);
+}
+
+
+void
+math_equation_shift(MathEquation *equation, gint count)
+{
+ MPNumber z;
+
+ if (!math_equation_get_number(equation, &z)) {
+ math_equation_set_status(equation,
+ /* This message is displayed in the status bar when a bit
+ shift operation is performed and the display does not contain a number */
+ _("No sane value to bitwise shift"));
+ return;
+ }
+
+ mp_shift(&z, count, &z);
+ math_equation_set_number(equation, &z);
+}
+
+
+void
+math_equation_toggle_bit(MathEquation *equation, guint bit)
+{
+ MPNumber x;
+ guint64 bits;
+ gboolean result;
+
+ result = math_equation_get_number(equation, &x);
+ if (result) {
+ MPNumber max;
+ mp_set_from_unsigned_integer(G_MAXUINT64, &max);
+ if (mp_is_negative(&x) || mp_is_greater_than(&x, &max))
+ result = FALSE;
+ else
+ bits = mp_cast_to_unsigned_int(&x);
+ }
+
+ if (!result) {
+ math_equation_set_status(equation,
+ /* Message displayed when cannot toggle bit in display*/
+ _("Displayed value not an integer"));
+ return;
+ }
+
+ bits ^= (1LL << (63 - bit));
+
+ mp_set_from_unsigned_integer(bits, &x);
+
+ // FIXME: Only do this if in ans format, otherwise set text in same format as previous number
+ math_equation_set_number(equation, &x);
+}
+
+
+/* Convert MP number to character string. */
+//FIXME: What to do with this?
+void
+display_make_number(MathEquation *equation, char *target, int target_len, const MPNumber *x)
+{
+ switch(equation->priv->format) {
+ case FIX:
+ mp_cast_to_string(x, equation->priv->base, equation->priv->base, equation->priv->accuracy, !equation->priv->show_zeroes, target, target_len);
+ break;
+ case SCI:
+ mp_cast_to_exponential_string(x, equation->priv->base, equation->priv->base, equation->priv->accuracy, !equation->priv->show_zeroes, false, target, target_len);
+ break;
+ case ENG:
+ mp_cast_to_exponential_string(x, equation->priv->base, equation->priv->base, equation->priv->accuracy, !equation->priv->show_zeroes, true, target, target_len);
+ break;
+ }
+}
+
+
+static void
+math_equation_set_property(GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ MathEquation *self;
+
+ self = MATH_EQUATION (object);
+
+ switch (prop_id) {
+ case PROP_STATUS:
+ math_equation_set_status(self, g_value_get_string(value));
+ break;
+ case PROP_DISPLAY:
+ math_equation_set(self, g_value_get_string(value));
+ break;
+ case PROP_NUMBER_MODE:
+ math_equation_set_number_mode(self, g_value_get_int(value));
+ break;
+ case PROP_ACCURACY:
+ math_equation_set_accuracy(self, g_value_get_int(value));
+ break;
+ case PROP_SHOW_THOUSANDS_SEPARATORS:
+ math_equation_set_show_thousands_separators(self, g_value_get_boolean(value));
+ break;
+ case PROP_SHOW_TRAILING_ZEROES:
+ math_equation_set_show_trailing_zeroes(self, g_value_get_boolean(value));
+ break;
+ case PROP_NUMBER_FORMAT:
+ math_equation_set_number_format(self, g_value_get_int(value));
+ break;
+ case PROP_BASE:
+ math_equation_set_base(self, g_value_get_int(value));
+ break;
+ case PROP_WORD_SIZE:
+ math_equation_set_word_size(self, g_value_get_int(value));
+ break;
+ case PROP_ANGLE_UNITS:
+ math_equation_set_angle_units(self, g_value_get_int(value));
+ break;
+ case PROP_SOURCE_CURRENCY:
+ math_equation_set_source_currency(self, g_value_get_string(value));
+ break;
+ case PROP_TARGET_CURRENCY:
+ math_equation_set_target_currency(self, g_value_get_string(value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+
+static void
+math_equation_get_property(GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ MathEquation *self;
+ gchar *text;
+
+ self = MATH_EQUATION (object);
+
+ switch (prop_id) {
+ case PROP_STATUS:
+ g_value_set_string(value, self->priv->state.status);
+ break;
+ case PROP_DISPLAY:
+ text = math_equation_get_display(self); 
+ g_value_set_string(value, text);
+ g_free(text);
+ break;
+ case PROP_EQUATION:
+ text = math_equation_get_equation(self);
+ g_value_set_string(value, text);
+ g_free(text);
+ break;
+ case PROP_NUMBER_MODE:
+ g_value_set_enum(value, self->priv->number_mode);
+ break;
+ case PROP_ACCURACY:
+ g_value_set_int(value, self->priv->accuracy);
+ break;
+ case PROP_SHOW_THOUSANDS_SEPARATORS:
+ g_value_set_boolean(value, self->priv->show_tsep);
+ break;
+ case PROP_SHOW_TRAILING_ZEROES:
+ g_value_set_boolean(value, self->priv->show_zeroes);
+ break;
+ case PROP_NUMBER_FORMAT:
+ g_value_set_enum(value, self->priv->format);
+ break;
+ case PROP_BASE:
+ g_value_set_int(value, math_equation_get_base(self));
+ break;
+ case PROP_WORD_SIZE:
+ g_value_set_int(value, self->priv->word_size);
+ break;
+ case PROP_ANGLE_UNITS:
+ g_value_set_enum(value, self->priv->angle_units);
+ break;
+ case PROP_SOURCE_CURRENCY:
+ g_value_set_string(value, self->priv->source_currency);
+ break;
+ case PROP_TARGET_CURRENCY:
+ g_value_set_string(value, self->priv->target_currency);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+
+static void
+math_equation_class_init (MathEquationClass *klass)
+{
+ static GEnumValue number_mode_values[] =
+ {
+ {NORMAL, "normal", "normal"},
+ {SUPERSCRIPT, "superscript", "superscript"},
+ {SUBSCRIPT, "subscript", "subscript"},
+ {0, NULL, NULL}
+ };
+ static GEnumValue number_format_values[] =
+ {
+ {FIX, "fixed-point", "fixed-point"},
+ {SCI, "scientific", "scientific"},
+ {ENG, "engineering", "engineering"},
+ {0, NULL, NULL}
+ };
+ static GEnumValue angle_unit_values[] =
+ {
+ {MP_RADIANS, "radians", "radians"},
+ {MP_DEGREES, "degrees", "degrees"},
+ {MP_GRADIANS, "gradians", "gradians"},
+ {0, NULL, NULL}
+ };
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->get_property = math_equation_get_property;
+ object_class->set_property = math_equation_set_property;
+
+ g_type_class_add_private (klass, sizeof (MathEquationPrivate));
+ 
+ number_mode_type = g_enum_register_static("NumberMode", number_mode_values);
+ number_format_type = g_enum_register_static("DisplayFormat", number_format_values);
+ angle_unit_type = g_enum_register_static("AngleUnit", angle_unit_values);
+
+ g_object_class_install_property(object_class,
+ PROP_STATUS,
+ g_param_spec_string("status",
+ "status",
+ "Equation status",
+ "",
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_DISPLAY,
+ g_param_spec_string("display",
+ "display",
+ "Displayed equation text",
+ "",
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_EQUATION,
+ g_param_spec_string("equation",
+ "equation",
+ "Equation text",
+ "",
+ G_PARAM_READABLE));
+ g_object_class_install_property(object_class,
+ PROP_NUMBER_MODE,
+ g_param_spec_enum("number-mode",
+ "number-mode",
+ "Input number mode",
+ number_mode_type,
+ NORMAL,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_ACCURACY,
+ g_param_spec_int("accuracy",
+ "accuracy",
+ "Display accuracy",
+ 0, 20, 9,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_SHOW_THOUSANDS_SEPARATORS,
+ g_param_spec_boolean("show-thousands-separators",
+ "show-thousands-separators",
+ "Show thousands separators",
+ TRUE,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_SHOW_TRAILING_ZEROES,
+ g_param_spec_boolean("show-trailing-zeroes",
+ "show-trailing-zeroes",
+ "Show trailing zeroes",
+ FALSE,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_NUMBER_FORMAT,
+ g_param_spec_enum("number-format",
+ "number-format",
+ "Display format",
+ number_format_type,
+ FIX,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_BASE,
+ g_param_spec_int("base",
+ "base",
+ "Default number base (derived from number-format)",
+ 2, 16, 10, 
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_WORD_SIZE,
+ g_param_spec_int("word-size",
+ "word-size",
+ "Word size in bits",
+ 8, 64, 64,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_ANGLE_UNITS,
+ g_param_spec_enum("angle-units",
+ "angle-units",
+ "Angle units",
+ angle_unit_type,
+ MP_DEGREES,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_SOURCE_CURRENCY,
+ g_param_spec_string("source-currency",
+ "source-currency",
+ "Source Currency",
+ "",
+ G_PARAM_READWRITE));
+ g_object_class_install_property(object_class,
+ PROP_TARGET_CURRENCY,
+ g_param_spec_string("target-currency",
+ "target-currency",
+ "target Currency",
+ "",
+ G_PARAM_READWRITE));
+}
+
+
+static void
+pre_insert_text_cb (MathEquation *equation,
+ GtkTextIter *location,
+ gchar *text,
+ gint len,
+ gpointer user_data)
+{
+ gunichar c;
+ 
+ if (equation->priv->in_reformat)
+ return;
+ 
+ /* If following a delete then have already pushed undo stack (GtkTextBuffer
+ doesn't indicate replace operations so we have to infer them) */
+ if (!equation->priv->in_delete)
+ math_equation_push_undo_stack(equation);
+
+ /* Clear result on next digit entered if cursor at end of line */
+ // FIXME Cursor
+ c = g_utf8_get_char(text);
+ if (g_unichar_isdigit(c) && math_equation_is_result(equation)) {
+ gtk_text_buffer_set_text(GTK_TEXT_BUFFER(equation), "", -1);
+ clear_ans(equation, FALSE);
+ gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER(equation), location);
+ }
+
+ if (equation->priv->ans_start) {
+ gint ans_start, ans_end;
+ gint offset;
+
+ offset = gtk_text_iter_get_offset(location);
+ get_ans_offsets(equation, &ans_start, &ans_end);
+ 
+ /* Inserted inside ans */
+ if (offset > ans_start && offset < ans_end)
+ clear_ans(equation, TRUE);
+ }
+}
+
+
+static gboolean
+on_delete(MathEquation *equation)
+{
+ equation->priv->in_delete = FALSE; 
+ return FALSE;
+}
+
+
+static void
+pre_delete_range_cb (MathEquation *equation,
+ GtkTextIter *start,
+ GtkTextIter *end,
+ gpointer user_data)
+{ 
+ if (equation->priv->in_reformat)
+ return;
+
+ math_equation_push_undo_stack(equation);
+
+ equation->priv->in_delete = TRUE;
+ g_idle_add((GSourceFunc)on_delete, equation);
+
+ if (equation->priv->ans_start) {
+ gint ans_start, ans_end;
+ gint start_offset, end_offset;
+
+ start_offset = gtk_text_iter_get_offset(start);
+ end_offset = gtk_text_iter_get_offset(end);
+ get_ans_offsets(equation, &ans_start, &ans_end);
+ 
+ /* Deleted part of ans */
+ if (start_offset < ans_end && end_offset > ans_start)
+ clear_ans(equation, TRUE);
+ }
+}
+
+
+static void
+insert_text_cb (MathEquation *equation,
+ GtkTextIter *location,
+ gchar *text,
+ gint len,
+ gpointer user_data)
+{
+ if (equation->priv->in_reformat)
+ return;
+
+ equation->priv->state.entered_multiply = strcmp(text, "×") == 0;
+ g_object_notify(G_OBJECT(equation), "display");
+}
+
+
+static void
+delete_range_cb (MathEquation *equation,
+ GtkTextIter *start,
+ GtkTextIter *end,
+ gpointer user_data)
+{
+ if (equation->priv->in_reformat)
+ return;
+
+ // FIXME: A replace will emit this both for delete-range and insert-text, can it be avoided?
+ g_object_notify(G_OBJECT(equation), "display");
+}
+
+
+static void
+math_equation_init(MathEquation *equation)
+{
+ /* Digits localized for the given language */
+ const char *digit_values = _("0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F");
+ const char *default_digits[] = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"};
+ gchar *radix, *tsep;
+ gchar **digits;
+ gboolean use_default_digits = FALSE;
+ int i;
+
+ equation->priv = G_TYPE_INSTANCE_GET_PRIVATE (equation, math_equation_get_type(), MathEquationPrivate);
+
+ // FIXME: Causes error
+ // (process:18573): Gtk-CRITICAL **: set_table: assertion buffer->tag_table == NULL' failed
+ equation->priv->ans_tag = gtk_text_buffer_create_tag(GTK_TEXT_BUFFER(equation), NULL, "weight", PANGO_WEIGHT_BOLD, NULL);
+
+ g_signal_connect(equation, "insert-text", G_CALLBACK(pre_insert_text_cb), equation);
+ g_signal_connect(equation, "delete-range", G_CALLBACK(pre_delete_range_cb), equation); 
+ g_signal_connect_after(equation, "insert-text", G_CALLBACK(insert_text_cb), equation);
+ g_signal_connect_after(equation, "delete-range", G_CALLBACK(delete_range_cb), equation);
+
+ digits = g_strsplit(digit_values, ",", -1);
+ for (i = 0; i < 16; i++) {
+ if (use_default_digits || digits[i] == NULL) {
+ use_default_digits = TRUE;
+ equation->priv->digits[i] = strdup(default_digits[i]);
+ }
+ else
+ equation->priv->digits[i] = strdup(digits[i]);
+ }
+ g_strfreev(digits);
+
+ setlocale(LC_NUMERIC, "");
+
+ radix = nl_langinfo(RADIXCHAR);
+ equation->priv->radix = radix ? g_locale_to_utf8(radix, -1, NULL, NULL, NULL) : g_strdup(".");
+ tsep = nl_langinfo(THOUSEP);
+ equation->priv->tsep = tsep ? g_locale_to_utf8(tsep, -1, NULL, NULL, NULL) : g_strdup(",");
+
+ equation->priv->tsep_count = 3;
+ 
+ equation->priv->variables = math_variables_new();
+
+ equation->priv->state.status = g_strdup("");
+ equation->priv->show_zeroes = FALSE;
+ equation->priv->show_tsep = FALSE;
+ equation->priv->format = FIX;
+ equation->priv->accuracy = 9;
+ equation->priv->word_size = 32;
+ equation->priv->angle_units = MP_DEGREES;
+ // FIXME: Pick based on locale
+ equation->priv->source_currency = g_strdup(currency_names[0].short_name);
+ equation->priv->target_currency = g_strdup(currency_names[0].short_name);
+ equation->priv->base = 10;
+
+ mp_set_from_integer(0, &equation->priv->state.ans);
+}
diff --git a/src/math-equation.h b/src/math-equation.h
new file mode 100644
index 0000000..e93137d
--- /dev/null
+++ b/src/math-equation.h
@@ -0,0 +1,133 @@
+/* Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef MATH_EQUATION_H
+#define MATH_EQUATION_H
+
+#include <glib-object.h>
+#include <gtk/gtk.h>
+#include "mp.h"
+#include "math-variables.h"
+
+G_BEGIN_DECLS
+
+#define MATH_EQUATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), math_equation_get_type(), MathEquation))
+
+typedef struct MathEquationPrivate MathEquationPrivate;
+
+typedef struct
+{
+ GtkTextBuffer parent_instance;
+ MathEquationPrivate *priv;
+} MathEquation;
+
+typedef struct
+{
+ GtkTextBufferClass parent_class;
+} MathEquationClass;
+
+/* Number display mode. */
+typedef enum {
+ FIX,
+ SCI,
+ ENG
+} DisplayFormat;
+
+typedef enum {
+ NORMAL,
+ SUPERSCRIPT,
+ SUBSCRIPT
+} NumberMode;
+
+GType math_equation_get_type(void);
+MathEquation *math_equation_new(void);
+
+MathVariables *math_equation_get_variables(MathEquation *equation);
+
+const gchar *math_equation_get_digit_text(MathEquation *equation, guint digit);
+const gchar *math_equation_get_numeric_point_text(MathEquation *equation);
+const gchar *math_equation_get_thousands_separator_text(MathEquation *equation);
+
+void math_equation_set_status(MathEquation *equation, const gchar *status);
+const gchar *math_equation_get_status(MathEquation *equation);
+
+gboolean math_equation_is_empty(MathEquation *equation);
+gboolean math_equation_is_result(MathEquation *equation);
+gchar *math_equation_get_display(MathEquation *equation);
+gchar *math_equation_get_equation(MathEquation *equation);
+gboolean math_equation_get_number(MathEquation *equation, MPNumber *z);
+
+void math_equation_set_number_mode(MathEquation *equation, NumberMode mode);
+NumberMode math_equation_get_number_mode(MathEquation *equation);
+
+void math_equation_set_accuracy(MathEquation *equation, gint accuracy);
+gint math_equation_get_accuracy(MathEquation *equation);
+
+void math_equation_set_show_thousands_separators(MathEquation *equation, gboolean visible);
+gboolean math_equation_get_show_thousands_separators(MathEquation *equation);
+
+void math_equation_set_show_trailing_zeroes(MathEquation *equation, gboolean visible);
+gboolean math_equation_get_show_trailing_zeroes(MathEquation *equation);
+
+void math_equation_set_number_format(MathEquation *equation, DisplayFormat format);
+DisplayFormat math_equation_get_number_format(MathEquation *equation);
+
+void math_equation_set_base(MathEquation *equation, gint base);
+gint math_equation_get_base(MathEquation *equation);
+
+void math_equation_set_word_size(MathEquation *equation, gint word_size);
+gint math_equation_get_word_size(MathEquation *equation);
+
+void math_equation_set_angle_units(MathEquation *equation, MPAngleUnit angle_unit);
+MPAngleUnit math_equation_get_angle_units(MathEquation *equation);
+
+void math_equation_set_source_currency(MathEquation *equation, const gchar *currency);
+const gchar *math_equation_get_source_currency(MathEquation *equation);
+
+void math_equation_set_target_currency(MathEquation *equation, const gchar *currency);
+const gchar *math_equation_get_target_currency(MathEquation *equation);
+
+const MPNumber *math_equation_get_answer(MathEquation *equation);
+
+void math_equation_copy(MathEquation *equation);
+void math_equation_paste(MathEquation *equation);
+void math_equation_undo(MathEquation *equation);
+void math_equation_redo(MathEquation *equation);
+void math_equation_store(MathEquation *equation, const gchar *name);
+void math_equation_recall(MathEquation *equation, const gchar *name);
+void math_equation_set(MathEquation *equation, const gchar *text);
+void math_equation_set_number(MathEquation *equation, const MPNumber *x);
+void math_equation_insert(MathEquation *equation, const gchar *text);
+void math_equation_insert_digit(MathEquation *equation, guint digit);
+void math_equation_insert_numeric_point(MathEquation *equation);
+void math_equation_insert_number(MathEquation *equation, const MPNumber *x);
+void math_equation_insert_subtract(MathEquation *equation);
+void math_equation_insert_exponent(MathEquation *equation);
+void math_equation_solve(MathEquation *equation);
+void math_equation_factorize(MathEquation *equation);
+void math_equation_delete(MathEquation *equation);
+void math_equation_backspace(MathEquation *equation);
+void math_equation_clear(MathEquation *equation);
+void math_equation_shift(MathEquation *equation, gint count);
+void math_equation_toggle_bit(MathEquation *equation, guint bit);
+
+//FIXME: Obsolete
+void display_make_number(MathEquation *equation, char *target, int target_len, const MPNumber *x);
+
+#endif /* MATH_EQUATION_H */
diff --git a/src/math-preferences.c b/src/math-preferences.c
new file mode 100644
index 0000000..c846523
--- /dev/null
+++ b/src/math-preferences.c
@@ -0,0 +1,401 @@
+/* Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "math-preferences.h"
+
+G_DEFINE_TYPE (MathPreferencesDialog, math_preferences, GTK_TYPE_DIALOG);
+
+enum {
+ PROP_0,
+ PROP_EQUATION
+};
+
+struct MathPreferencesDialogPrivate
+{
+ MathEquation *equation;
+ GtkBuilder *ui;
+};
+
+#define UI_DIALOGS_FILE UI_DIR "/preferences.ui"
+#define GET_WIDGET(ui, name) \
+ GTK_WIDGET(gtk_builder_get_object(ui, name))
+
+
+MathPreferencesDialog *
+math_preferences_dialog_new(MathEquation *equation)
+{ 
+ return g_object_new (math_preferences_get_type(), "equation", equation, NULL);
+}
+
+
+static void
+preferences_response_cb(GtkWidget *widget, gint id)
+{
+ gtk_widget_hide(widget);
+}
+
+
+static gboolean
+preferences_dialog_delete_cb(GtkWidget *widget, GdkEvent *event)
+{
+ preferences_response_cb(widget, 0);
+ return TRUE;
+}
+
+
+void number_format_combobox_changed_cb(GtkWidget *combo, MathPreferencesDialog *dialog);
+G_MODULE_EXPORT
+void
+number_format_combobox_changed_cb(GtkWidget *combo, MathPreferencesDialog *dialog)
+{
+ DisplayFormat value;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+
+ model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+ gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo), &iter);
+ gtk_tree_model_get(model, &iter, 1, &value, -1);
+ math_equation_set_number_format(dialog->priv->equation, value);
+}
+
+
+void angle_unit_combobox_changed_cb(GtkWidget *combo, MathPreferencesDialog *dialog);
+G_MODULE_EXPORT
+void
+angle_unit_combobox_changed_cb(GtkWidget *combo, MathPreferencesDialog *dialog)
+{
+ MPAngleUnit value;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+
+ model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+ gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo), &iter);
+ gtk_tree_model_get(model, &iter, 1, &value, -1);
+ math_equation_set_angle_units(dialog->priv->equation, value);
+}
+
+
+void word_size_combobox_changed_cb(GtkWidget *combo, MathPreferencesDialog *dialog);
+G_MODULE_EXPORT
+void
+word_size_combobox_changed_cb(GtkWidget *combo, MathPreferencesDialog *dialog)
+{
+ gint value;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+
+ model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+ gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo), &iter);
+ gtk_tree_model_get(model, &iter, 1, &value, -1);
+ math_equation_set_word_size(dialog->priv->equation, value);
+}
+
+
+void decimal_places_spin_change_value_cb(GtkWidget *spin, MathPreferencesDialog *dialog);
+G_MODULE_EXPORT
+void
+decimal_places_spin_change_value_cb(GtkWidget *spin, MathPreferencesDialog *dialog)
+{
+ gint value = 0;
+
+ value = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin));
+ math_equation_set_accuracy(dialog->priv->equation, value);
+}
+
+
+void thousands_separator_check_toggled_cb(GtkWidget *check, MathPreferencesDialog *dialog);
+G_MODULE_EXPORT
+void
+thousands_separator_check_toggled_cb(GtkWidget *check, MathPreferencesDialog *dialog)
+{
+ gboolean value;
+
+ value = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check));
+ math_equation_set_show_thousands_separators(dialog->priv->equation, value);
+}
+
+
+void trailing_zeroes_check_toggled_cb(GtkWidget *check, MathPreferencesDialog *dialog);
+G_MODULE_EXPORT
+void
+trailing_zeroes_check_toggled_cb(GtkWidget *check, MathPreferencesDialog *dialog)
+{
+ gboolean value;
+
+ value = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check));
+ math_equation_set_show_trailing_zeroes(dialog->priv->equation, value);
+}
+
+
+static void
+set_combo_box_from_int(GtkWidget *combo, int value)
+{
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ gboolean valid;
+
+ model = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+ valid = gtk_tree_model_get_iter_first(model, &iter);
+
+ while (valid) {
+ gint v;
+
+ gtk_tree_model_get(model, &iter, 1, &v, -1);
+ if (v == value)
+ break;
+ valid = gtk_tree_model_iter_next(model, &iter);
+ }
+ if (!valid)
+ valid = gtk_tree_model_get_iter_first(model, &iter);
+
+ gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo), &iter);
+}
+
+
+static void
+accuracy_cb(MathEquation *equation, GParamSpec *spec, MathPreferencesDialog *dialog)
+{
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(gtk_builder_get_object(dialog->priv->ui, "decimal_places_spin")),
+ math_equation_get_accuracy(equation));
+}
+
+
+static void
+show_thousands_separators_cb(MathEquation *equation, GParamSpec *spec, MathPreferencesDialog *dialog)
+{
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(dialog->priv->ui, "thousands_separator_check")),
+ math_equation_get_show_thousands_separators(equation));
+}
+
+
+static void
+show_trailing_zeroes_cb(MathEquation *equation, GParamSpec *spec, MathPreferencesDialog *dialog)
+{
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(dialog->priv->ui, "trailing_zeroes_check")),
+ math_equation_get_show_trailing_zeroes(equation));
+}
+
+
+static void
+number_format_cb(MathEquation *equation, GParamSpec *spec, MathPreferencesDialog *dialog)
+{
+ set_combo_box_from_int(GET_WIDGET(dialog->priv->ui, "number_format_combobox"), math_equation_get_number_format(equation));
+}
+
+
+static void
+word_size_cb(MathEquation *equation, GParamSpec *spec, MathPreferencesDialog *dialog)
+{
+ set_combo_box_from_int(GET_WIDGET(dialog->priv->ui, "word_size_combobox"), math_equation_get_word_size(equation));
+}
+
+
+static void
+angle_unit_cb(MathEquation *equation, GParamSpec *spec, MathPreferencesDialog *dialog)
+{
+ set_combo_box_from_int(GET_WIDGET(dialog->priv->ui, "angle_unit_combobox"), math_equation_get_angle_units(equation)); 
+}
+
+
+static void
+create_gui(MathPreferencesDialog *dialog)
+{
+ GtkWidget *widget;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ GtkCellRenderer *renderer;
+ gchar *string, **tokens;
+ GError *error = NULL;
+ static gchar *objects[] = { "preferences_table", "angle_unit_model", "number_format_model",
+ "word_size_model", "decimal_places_adjustment", "number_base_model", NULL };
+
+ // FIXME: Handle errors
+ dialog->priv->ui = gtk_builder_new();
+ gtk_builder_add_objects_from_file(dialog->priv->ui, UI_DIALOGS_FILE, objects, &error);
+ if (error)
+ g_warning("Error loading preferences UI: %s", error->message);
+ g_clear_error(&error);
+
+ gtk_window_set_title(GTK_WINDOW(dialog),
+ /* Title of preferences dialog */
+ _("Preferences"));
+ gtk_window_set_icon_name(GTK_WINDOW(dialog), "accessories-calculator");
+ gtk_container_set_border_width(GTK_CONTAINER(dialog), 8);
+ gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
+ gtk_dialog_add_button(GTK_DIALOG(dialog),
+ /* Label on close button in preferences dialog */
+ _("_Close"), 0);
+ g_signal_connect(dialog, "response", G_CALLBACK(preferences_response_cb), NULL);
+ g_signal_connect(dialog, "delete-event", G_CALLBACK(preferences_dialog_delete_cb), NULL);
+ gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), GET_WIDGET(dialog->priv->ui, "preferences_table"), TRUE, TRUE, 0);
+
+ widget = GET_WIDGET(dialog->priv->ui, "angle_unit_combobox");
+ model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
+ gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0,
+ /* Preferences dialog: Angle unit combo box: Use degrees for trigonometric calculations */
+ _("Degrees"), 1, MP_DEGREES, -1);
+ gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0,
+ /* Preferences dialog: Angle unit combo box: Use radians for trigonometric calculations */
+ _("Radians"), 1, MP_RADIANS, -1);
+ gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0,
+ /* Preferences dialog: Angle unit combo box: Use gradians for trigonometric calculations */
+ _("Gradians"), 1, MP_GRADIANS, -1);
+ renderer = gtk_cell_renderer_text_new();
+ gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(widget), renderer, TRUE);
+ gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(widget), renderer, "text", 0);
+
+ widget = GET_WIDGET(dialog->priv->ui, "number_format_combobox");
+ model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
+ gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0,
+ /* Number display mode combo: Fixed, e.g. 1234 */
+ _("Fixed"), 1, FIX, -1);
+ gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0,
+ /* Number display mode combo: Scientific, e.g. 1.234×10^3 */
+ _("Scientific"), 1, SCI, -1);
+ gtk_list_store_append(GTK_LIST_STORE(model), &iter);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0,
+ /* Number display mode combo: Engineering, e.g. 1.234k */
+ _("Engineering"), 1, ENG, -1);
+ renderer = gtk_cell_renderer_text_new();
+ gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(widget), renderer, TRUE);
+ gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(widget), renderer, "text", 0);
+
+ widget = GET_WIDGET(dialog->priv->ui, "word_size_combobox");
+ renderer = gtk_cell_renderer_text_new();
+ gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(widget), renderer, TRUE);
+ gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(widget), renderer, "text", 0);
+
+ /* Label used in preferences dialog. The %d is replaced by a spinbutton */
+ string = _("Show %d decimal _places");
+ tokens = g_strsplit(string, "%d", 2);
+ widget = GET_WIDGET(dialog->priv->ui, "decimal_places_label1");
+ if (tokens[0])
+ string = g_strstrip(tokens[0]);
+ else
+ string = "";
+ if (string[0] != '\0')
+ gtk_label_set_text_with_mnemonic(GTK_LABEL(widget), string);
+ else
+ gtk_widget_hide(widget);
+
+ widget = GET_WIDGET(dialog->priv->ui, "decimal_places_label2");
+ if (tokens[0] && tokens[1])
+ string = g_strstrip(tokens[1]);
+ else
+ string = "";
+ if (string[0] != '\0')
+ gtk_label_set_text_with_mnemonic(GTK_LABEL(widget), string);
+ else
+ gtk_widget_hide(widget);
+
+ g_strfreev(tokens);
+
+ gtk_builder_connect_signals(dialog->priv->ui, dialog);
+
+ g_signal_connect(dialog->priv->equation, "notify::accuracy", G_CALLBACK(accuracy_cb), dialog);
+ g_signal_connect(dialog->priv->equation, "notify::show-thousands-separators", G_CALLBACK(show_thousands_separators_cb), dialog);
+ g_signal_connect(dialog->priv->equation, "notify::show-trailing_zeroes", G_CALLBACK(show_trailing_zeroes_cb), dialog);
+ g_signal_connect(dialog->priv->equation, "notify::number-format", G_CALLBACK(number_format_cb), dialog);
+ g_signal_connect(dialog->priv->equation, "notify::word-size", G_CALLBACK(word_size_cb), dialog);
+ g_signal_connect(dialog->priv->equation, "notify::angle-units", G_CALLBACK(angle_unit_cb), dialog);
+
+ accuracy_cb(dialog->priv->equation, NULL, dialog);
+ show_thousands_separators_cb(dialog->priv->equation, NULL, dialog);
+ show_trailing_zeroes_cb(dialog->priv->equation, NULL, dialog);
+ number_format_cb(dialog->priv->equation, NULL, dialog);
+ word_size_cb(dialog->priv->equation, NULL, dialog);
+ angle_unit_cb(dialog->priv->equation, NULL, dialog);
+}
+
+
+static void
+math_preferences_set_property(GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ MathPreferencesDialog *self;
+
+ self = MATH_PREFERENCES (object);
+
+ switch (prop_id) {
+ case PROP_EQUATION:
+ self->priv->equation = g_value_get_object (value);
+ create_gui(self);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+
+static void
+math_preferences_get_property(GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ MathPreferencesDialog *self;
+
+ self = MATH_PREFERENCES (object);
+
+ switch (prop_id) {
+ case PROP_EQUATION:
+ g_value_set_object (value, self->priv->equation);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+
+static void
+math_preferences_class_init (MathPreferencesDialogClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->get_property = math_preferences_get_property;
+ object_class->set_property = math_preferences_set_property;
+
+ g_type_class_add_private (klass, sizeof (MathPreferencesDialogPrivate));
+
+ g_object_class_install_property(object_class,
+ PROP_EQUATION,
+ g_param_spec_object("equation",
+ "equation",
+ "Equation being configured",
+ math_equation_get_type(),
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+}
+
+
+static void
+math_preferences_init(MathPreferencesDialog *dialog)
+{
+ dialog->priv = G_TYPE_INSTANCE_GET_PRIVATE (dialog, math_preferences_get_type(), MathPreferencesDialogPrivate);
+}
diff --git a/src/math-preferences.h b/src/math-preferences.h
new file mode 100644
index 0000000..487a68e
--- /dev/null
+++ b/src/math-preferences.h
@@ -0,0 +1,47 @@
+/* Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef MATH_PREFERENCES_H
+#define MATH_PREFERENCES_H
+
+#include <glib-object.h>
+#include <gtk/gtk.h>
+#include "math-equation.h"
+
+G_BEGIN_DECLS
+
+#define MATH_PREFERENCES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), math_preferences_get_type(), MathPreferencesDialog))
+
+typedef struct MathPreferencesDialogPrivate MathPreferencesDialogPrivate;
+
+typedef struct
+{
+ GtkDialog parent_instance;
+ MathPreferencesDialogPrivate *priv;
+} MathPreferencesDialog;
+
+typedef struct
+{
+ GtkDialogClass parent_class;
+} MathPreferencesDialogClass;
+
+GType math_preferences_get_type(void);
+
+MathPreferencesDialog *math_preferences_dialog_new(MathEquation *equation);
+
+#endif /* MATH_PREFERENCES_H */
diff --git a/src/math-variables.c b/src/math-variables.c
new file mode 100644
index 0000000..b4f7720
--- /dev/null
+++ b/src/math-variables.c
@@ -0,0 +1,163 @@
+/* Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "math-variables.h"
+
+
+struct MathVariablesPrivate
+{
+ gchar *file_name;
+ GHashTable *registers;
+};
+
+G_DEFINE_TYPE (MathVariables, math_variables, G_TYPE_OBJECT);
+
+
+MathVariables *
+math_variables_new()
+{
+ return g_object_new (math_variables_get_type(), NULL);
+}
+
+
+static void
+registers_load(MathVariables *variables)
+{
+ FILE *f;
+ char line[1024];
+ 
+ f = fopen(variables->priv->file_name, "r");
+ if (!f)
+ return;
+ 
+ g_hash_table_remove_all(variables->priv->registers);
+
+ while (fgets(line, 1024, f) != NULL)
+ {
+ char *name, *value;
+ MPNumber *t;
+ 
+ value = strchr(line, '=');
+ if (!value)
+ continue;
+ *value = '\0';
+ value = value + 1;
+ 
+ name = g_strstrip(line);
+ value = g_strstrip(value);
+
+ t = g_malloc(sizeof(MPNumber));
+ if (mp_set_from_string(value, 10, t) == 0)
+ g_hash_table_insert(variables->priv->registers, g_strdup(name), t);
+ else
+ g_free(t);
+ }
+ fclose(f);
+}
+
+
+static void
+registers_save(MathVariables *variables)
+{
+ gchar *dir;
+ FILE *f;
+ GHashTableIter iter;
+ gpointer key, val;
+
+ dir = g_path_get_dirname(variables->priv->file_name);
+ g_mkdir_with_parents(dir, 0700);
+ g_free(dir);
+
+ f = fopen(variables->priv->file_name, "w");
+ if (!f)
+ return;
+ 
+ g_hash_table_iter_init(&iter, variables->priv->registers);
+ while (g_hash_table_iter_next(&iter, &key, &val))
+ {
+ gchar *name = key;
+ MPNumber *value = val;
+ char number[1024];
+
+ mp_cast_to_string(value, 10, 10, 50, TRUE, number, 1024);
+ fprintf(f, "%s=%s\n", name, number);
+ }
+ fclose(f);
+}
+
+
+// FIXME: Sort
+gchar **
+math_variables_get_names(MathVariables *variables)
+{
+ GHashTableIter iter;
+ gpointer key;
+ gint i = 0;
+ gchar **names;
+ 
+ names = g_malloc0(sizeof(gchar *) * (g_hash_table_size(variables->priv->registers) + 1));
+
+ g_hash_table_iter_init(&iter, variables->priv->registers);
+ while (g_hash_table_iter_next(&iter, &key, NULL))
+ {
+ gchar *name = key;
+ names[i] = g_strdup(name);
+ i++;
+ }
+ names[i] = NULL;
+
+ return names;
+}
+
+
+void
+math_variables_set_value(MathVariables *variables, const char *name, const MPNumber *value)
+{
+ MPNumber *t;
+ t = g_malloc(sizeof(MPNumber));
+ mp_set_from_mp(value, t);
+ g_hash_table_insert(variables->priv->registers, g_strdup(name), t);
+ registers_save(variables);
+}
+
+
+MPNumber *
+math_variables_get_value(MathVariables *variables, const char *name)
+{
+ return g_hash_table_lookup(variables->priv->registers, name);
+}
+
+
+static void
+math_variables_class_init (MathVariablesClass *klass)
+{
+ g_type_class_add_private (klass, sizeof (MathVariablesPrivate));
+}
+
+
+static void
+math_variables_init(MathVariables *variables)
+{
+ variables->priv = G_TYPE_INSTANCE_GET_PRIVATE (variables, math_variables_get_type(), MathVariablesPrivate);
+ variables->priv->registers = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
+ variables->priv->file_name = g_build_filename(g_get_user_data_dir(), "gcalctool", "registers", NULL);
+ registers_load(variables);
+}
diff --git a/src/math-variables.h b/src/math-variables.h
new file mode 100644
index 0000000..b2317b0
--- /dev/null
+++ b/src/math-variables.h
@@ -0,0 +1,52 @@
+/* Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef MATH_VARIABLES_H
+#define MATH_VARIABLES_H
+
+#include <glib-object.h>
+#include "mp.h"
+
+G_BEGIN_DECLS
+
+#define MATH_VARIABLES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), math_equation_get_type(), MathVariables))
+
+typedef struct MathVariablesPrivate MathVariablesPrivate;
+
+typedef struct
+{
+ GObject parent_instance;
+ MathVariablesPrivate *priv;
+} MathVariables;
+
+typedef struct
+{
+ GObjectClass parent_class;
+} MathVariablesClass;
+
+GType math_variables_get_type(void);
+
+MathVariables *math_variables_new(void);
+
+gchar **math_variables_get_names(MathVariables *variables);
+
+void math_variables_set_value(MathVariables *variables, const char *name, const MPNumber *value);
+
+MPNumber *math_variables_get_value(MathVariables *variables, const char *name);
+
+#endif /* MATH_VARIABLES_H */
diff --git a/src/math-window.c b/src/math-window.c
new file mode 100644
index 0000000..0daf030
--- /dev/null
+++ b/src/math-window.c
@@ -0,0 +1,527 @@
+/* Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+
+#include "math-window.h"
+#include "math-preferences.h"
+
+enum {
+ PROP_0,
+ PROP_EQUATION
+};
+
+struct MathWindowPrivate
+{
+ GtkWidget *menu_bar;
+ MathEquation *equation;
+ MathDisplay *display;
+ MathButtons *buttons;
+ MathPreferencesDialog *preferences_dialog;
+ gboolean right_aligned;
+ GtkWidget *mode_basic_menu_item, *mode_advanced_menu_item, *mode_financial_menu_item, *mode_programming_menu_item;
+};
+
+G_DEFINE_TYPE (MathWindow, math_window, GTK_TYPE_WINDOW);
+
+enum {
+ QUIT,
+ LAST_SIGNAL
+};
+static guint signals[LAST_SIGNAL] = { 0, };
+
+
+MathWindow *
+math_window_new(MathEquation *equation)
+{
+ return g_object_new (math_window_get_type(), "equation", equation, NULL);
+}
+
+
+GtkWidget *
+math_window_get_menu_bar(MathWindow *window)
+{
+ return window->priv->menu_bar;
+}
+
+
+MathEquation *math_window_get_equation(MathWindow *window)
+{
+ return window->priv->equation;
+}
+
+
+MathDisplay *
+math_window_get_display(MathWindow *window)
+{
+ return window->priv->display;
+}
+
+
+MathButtons *
+math_window_get_buttons(MathWindow *window)
+{
+ return window->priv->buttons;
+}
+
+
+void
+math_window_critical_error(MathWindow *window, const gchar *title, const gchar *contents)
+{
+ GtkWidget *dialog;
+
+ dialog = gtk_message_dialog_new(NULL, 0,
+ GTK_MESSAGE_ERROR,
+ GTK_BUTTONS_NONE,
+ "%s", title);
+ gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
+ "%s", contents);
+ gtk_dialog_add_buttons(GTK_DIALOG(dialog), GTK_STOCK_QUIT, GTK_RESPONSE_ACCEPT, NULL);
+
+ gtk_dialog_run(GTK_DIALOG(dialog));
+
+ g_signal_emit(window, signals[QUIT], 0);
+}
+
+
+static void
+copy_cb(GtkWidget *widget, MathWindow *window)
+{
+ math_equation_copy (window->priv->equation); 
+}
+
+
+static void
+paste_cb(GtkWidget *widget, MathWindow *window)
+{
+ math_equation_paste (window->priv->equation);
+}
+
+
+static void
+undo_cb(GtkWidget *widget, MathWindow *window)
+{
+ math_equation_undo(window->priv->equation);
+}
+
+
+static void
+redo_cb(GtkWidget *widget, MathWindow *window)
+{
+ math_equation_redo(window->priv->equation);
+}
+
+
+static void
+mode_changed_cb(GtkWidget *menu, MathWindow *window)
+{
+ int mode;
+
+ if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menu)))
+ return;
+
+ mode = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu), "calcmode"));
+ math_buttons_set_mode(window->priv->buttons, mode);
+}
+
+
+static void
+show_preferences_cb(GtkMenuItem *menu, MathWindow *window)
+{
+ if (!window->priv->preferences_dialog) {
+ window->priv->preferences_dialog = math_preferences_dialog_new(window->priv->equation);
+ gtk_window_set_transient_for(GTK_WINDOW(window->priv->preferences_dialog), GTK_WINDOW(window));
+ }
+ gtk_window_present(GTK_WINDOW(window->priv->preferences_dialog));
+}
+
+
+static void
+help_cb(GtkWidget *widget, MathWindow *window)
+{
+ GdkScreen *screen;
+ GError *error = NULL;
+
+ screen = gtk_widget_get_screen (GTK_WIDGET (window));
+ gtk_show_uri (screen, "ghelp:gcalctool", gtk_get_current_event_time (), &error);
+
+ if (error != NULL)
+ {
+ GtkWidget *d;
+ /* Translators: Error message displayed when unable to launch help browser */
+ const char *message = _("Unable to open help file");
+
+ d = gtk_message_dialog_new (GTK_WINDOW (window),
+ GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
+ "%s", message);
+ gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (d),
+ "%s", error->message);
+ g_signal_connect (d, "response", G_CALLBACK (gtk_widget_destroy), NULL);
+ gtk_window_present (GTK_WINDOW (d));
+
+ g_error_free (error);
+ }
+}
+
+
+static void
+about_cb(GtkWidget *widget, MathWindow *window)
+{
+ const gchar *authors[] = {
+ "Rich Burridge <[email protected]>",
+ "Robert Ancell <[email protected]>",
+ "Klaus Niederkrüger <[email protected]>",
+ NULL
+ };
+ const gchar *documenters[] = {
+ "Sun Microsystems",
+ NULL
+ };
+
+ /* The translator credits. Please translate this with your name(s). */
+ const gchar *translator_credits = _("translator-credits");
+
+ /* The license this software is under (GPL2+) */
+ char *license = _("Gcalctool is free software; you can redistribute it and/or modify\n"
+ "it under the terms of the GNU General Public License as published by\n"
+ "the Free Software Foundation; either version 2 of the License, or\n"
+ "(at your option) any later version.\n"
+ "\n"
+ "Gcalctool is distributed in the hope that it will be useful,\n"
+ "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+ "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
+ "GNU General Public License for more details.\n"
+ "\n"
+ "You should have received a copy of the GNU General Public License\n"
+ "along with Gcalctool; if not, write to the Free Software Foundation, Inc.,\n"
+ "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA");
+
+ gtk_show_about_dialog(GTK_WINDOW(window),
+ "name",
+ /* Program name in the about dialog */
+ _("Gcalctool"),
+ "version", VERSION,
+ "copyright",
+ /* Copyright notice in the about dialog */
+ _("\xc2\xa9 1986–2010 The Gcalctool authors"),
+ "license", license,
+ "comments",
+ /* Short description in the about dialog */
+ _("Calculator with financial and scientific modes."),
+ "authors", authors,
+ "documenters", documenters,
+ "translator_credits", translator_credits,
+ "logo-icon-name", "accessories-calculator",
+ NULL);
+}
+
+
+static void
+quit_cb(GtkWidget *widget, MathWindow *window)
+{
+ g_signal_emit(window, signals[QUIT], 0);
+}
+
+
+static gboolean
+key_press_cb(MathWindow *window, GdkEventKey *event)
+{
+ gboolean result;
+ g_signal_emit_by_name(window->priv->display, "key-press-event", event, &result);
+ return result;
+}
+
+
+static void
+delete_cb(MathWindow *window, GdkEvent *event)
+{
+ g_signal_emit(window, signals[QUIT], 0);
+}
+
+
+static void
+scroll_changed_cb(GtkAdjustment *adjustment, MathWindow *window)
+{
+ if (window->priv->right_aligned)
+ gtk_adjustment_set_value(adjustment, gtk_adjustment_get_upper(adjustment) - gtk_adjustment_get_page_size(adjustment));
+}
+
+
+static void
+scroll_value_changed_cb(GtkAdjustment *adjustment, MathWindow *window)
+{
+ if (gtk_adjustment_get_value(adjustment) == gtk_adjustment_get_upper(adjustment) - gtk_adjustment_get_page_size(adjustment))
+ window->priv->right_aligned = TRUE;
+ else
+ window->priv->right_aligned = FALSE;
+}
+
+
+static void
+button_mode_changed_cb(MathButtons *buttons, GParamSpec *spec, MathWindow *window)
+{
+ GtkWidget *menu;
+
+ switch(math_buttons_get_mode(buttons))
+ {
+ default:
+ case BASIC:
+ menu = window->priv->mode_basic_menu_item;
+ //FIXME: Should it revert to decimal mode? math_equation_set_number_format(window->priv->equation, DEC);
+ break;
+
+ case ADVANCED:
+ menu = window->priv->mode_advanced_menu_item;
+ break;
+
+ case FINANCIAL:
+ menu = window->priv->mode_financial_menu_item;
+ break;
+
+ case PROGRAMMING:
+ menu = window->priv->mode_programming_menu_item;
+ break;
+ }
+ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu), TRUE);
+}
+
+
+static GtkWidget *
+add_menu(GtkWidget *menu_bar, const gchar *name)
+{
+ GtkWidget *menu_item, *menu;
+
+ menu_item = gtk_menu_item_new_with_mnemonic(name);
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), menu_item);
+ gtk_widget_show(menu_item);
+ menu = gtk_menu_new();
+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), menu);
+
+ return menu;
+}
+
+
+static GtkWidget *
+add_menu_item(GtkWidget *menu, GtkWidget *menu_item, GCallback callback, gpointer callback_data)
+{
+ gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+ gtk_widget_show(menu_item);
+ if (callback)
+ g_signal_connect(G_OBJECT(menu_item), "activate", callback, callback_data);
+ return menu_item;
+}
+
+
+static GtkWidget *
+radio_menu_item_new(GSList **group, const gchar *name)
+{
+ GtkWidget *menu_item;
+ menu_item = gtk_radio_menu_item_new_with_mnemonic(*group, name);
+ *group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menu_item));
+ return menu_item;
+}
+
+
+static void
+create_menu(MathWindow *window)
+{
+ GtkAccelGroup *accel_group;
+ GtkWidget *menu, *menu_item;
+ GSList *group = NULL;
+ 
+ accel_group = gtk_accel_group_new();
+ gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
+
+ /* Calculator menu */ 
+ #define CALCULATOR_MENU_LABEL _("_Calculator")
+ /* Mode menu */
+ #define MODE_MENU_LABEL _("_Mode")
+ /* Help menu label */
+ #define HELP_MENU_LABEL _("_Help")
+ /* Basic menu label */ 
+ #define MODE_BASIC_LABEL _("_Basic")
+ /* Advanced menu label */ 
+ #define MODE_ADVANCED_LABEL _("_Advanced")
+ /* Financial menu label */ 
+ #define MODE_FINANCIAL_LABEL _("_Financial")
+ /* Programming menu label */
+ #define MODE_PROGRAMMING_LABEL _("_Programming")
+ /* Help>Contents menu label */
+ #define HELP_CONTENTS_LABEL _("_Contents")
+
+ menu = add_menu(window->priv->menu_bar, CALCULATOR_MENU_LABEL);
+ add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY, accel_group), G_CALLBACK(copy_cb), window);
+ add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE, accel_group), G_CALLBACK(paste_cb), window);
+ menu_item = add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_UNDO, accel_group), G_CALLBACK(undo_cb), window);
+ gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_z, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
+ menu_item = add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_REDO, accel_group), G_CALLBACK(redo_cb), window);
+ gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_z, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE);
+ add_menu_item(menu, gtk_separator_menu_item_new(), NULL, NULL);
+ add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES, accel_group), G_CALLBACK(show_preferences_cb), window);
+ add_menu_item(menu, gtk_separator_menu_item_new(), NULL, NULL);
+ menu_item = add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, accel_group), G_CALLBACK(quit_cb), window);
+ gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_w, GDK_CONTROL_MASK, 0);
+
+ menu = add_menu(window->priv->menu_bar, MODE_MENU_LABEL);
+ window->priv->mode_basic_menu_item = add_menu_item(menu, radio_menu_item_new(&group, MODE_BASIC_LABEL), G_CALLBACK(mode_changed_cb), window);
+ g_object_set_data(G_OBJECT(window->priv->mode_basic_menu_item), "calcmode", GINT_TO_POINTER(BASIC));
+ window->priv->mode_advanced_menu_item = add_menu_item(menu, radio_menu_item_new(&group, MODE_ADVANCED_LABEL), G_CALLBACK(mode_changed_cb), window);
+ g_object_set_data(G_OBJECT(window->priv->mode_advanced_menu_item), "calcmode", GINT_TO_POINTER(ADVANCED));
+ window->priv->mode_financial_menu_item = add_menu_item(menu, radio_menu_item_new(&group, MODE_FINANCIAL_LABEL), G_CALLBACK(mode_changed_cb), window);
+ g_object_set_data(G_OBJECT(window->priv->mode_financial_menu_item), "calcmode", GINT_TO_POINTER(FINANCIAL));
+ window->priv->mode_programming_menu_item = add_menu_item(menu, radio_menu_item_new(&group, MODE_PROGRAMMING_LABEL), G_CALLBACK(mode_changed_cb), window);
+ g_object_set_data(G_OBJECT(window->priv->mode_programming_menu_item), "calcmode", GINT_TO_POINTER(PROGRAMMING));
+
+ menu = add_menu(window->priv->menu_bar, HELP_MENU_LABEL);
+ menu_item = add_menu_item(menu, gtk_menu_item_new_with_mnemonic(HELP_CONTENTS_LABEL), G_CALLBACK(help_cb), window);
+ gtk_widget_add_accelerator(menu_item, "activate", accel_group, GDK_F1, 0, GTK_ACCEL_VISIBLE);
+ add_menu_item(menu, gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, accel_group), G_CALLBACK(about_cb), window);
+}
+
+
+static void
+create_gui(MathWindow *window)
+{
+ GtkWidget *main_vbox, *vbox;
+ GtkWidget *scrolled_window;
+ 
+ main_vbox = gtk_vbox_new(FALSE, 0);
+ gtk_container_add(GTK_CONTAINER(window), main_vbox);
+ gtk_widget_show(main_vbox);
+
+ window->priv->menu_bar = gtk_menu_bar_new();
+ gtk_box_pack_start(GTK_BOX(main_vbox), window->priv->menu_bar, TRUE, TRUE, 0);
+ gtk_widget_show(window->priv->menu_bar);
+ 
+ create_menu(window);
+
+ vbox = gtk_vbox_new(FALSE, 6);
+ gtk_container_set_border_width(GTK_CONTAINER(vbox), 6);
+ gtk_box_pack_start(GTK_BOX(main_vbox), vbox, TRUE, TRUE, 0); 
+ gtk_widget_show(vbox);
+
+ scrolled_window = gtk_scrolled_window_new(NULL, NULL);
+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
+ gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window), GTK_SHADOW_IN);
+ gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(scrolled_window), TRUE, TRUE, 0);
+ g_signal_connect(gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(scrolled_window)), "changed", G_CALLBACK(scroll_changed_cb), window);
+ g_signal_connect(gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(scrolled_window)), "value-changed", G_CALLBACK(scroll_value_changed_cb), window);
+ window->priv->right_aligned = TRUE;
+ gtk_widget_show(scrolled_window);
+
+ window->priv->display = math_display_new_with_equation(window->priv->equation);
+ gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), GTK_WIDGET(window->priv->display));
+ gtk_widget_show(GTK_WIDGET(window->priv->display));
+
+ window->priv->buttons = math_buttons_new(window->priv->equation);
+ g_signal_connect(window->priv->buttons, "notify::mode", G_CALLBACK(button_mode_changed_cb), window);
+ button_mode_changed_cb(window->priv->buttons, NULL, window);
+ gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(window->priv->buttons), TRUE, TRUE, 0);
+ gtk_widget_show(GTK_WIDGET(window->priv->buttons));
+}
+
+
+static void
+math_window_set_property(GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ MathWindow *self;
+
+ self = MATH_WINDOW (object);
+
+ switch (prop_id) {
+ case PROP_EQUATION:
+ self->priv->equation = g_value_get_object (value);
+ create_gui(self);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+
+static void
+math_window_get_property(GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ MathWindow *self;
+
+ self = MATH_WINDOW (object);
+
+ switch (prop_id) {
+ case PROP_EQUATION:
+ g_value_set_object (value, self->priv->equation);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+
+static void
+math_window_class_init (MathWindowClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->get_property = math_window_get_property;
+ object_class->set_property = math_window_set_property;
+
+ g_type_class_add_private (klass, sizeof (MathWindowPrivate));
+
+ g_object_class_install_property(object_class,
+ PROP_EQUATION,
+ g_param_spec_object("equation",
+ "equation",
+ "Equation being calculated",
+ math_equation_get_type(),
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+
+ signals[QUIT] =
+ g_signal_new ("quit",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (MathWindowClass, quit),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+}
+
+
+static void
+math_window_init(MathWindow *window)
+{
+ window->priv = G_TYPE_INSTANCE_GET_PRIVATE (window, math_window_get_type(), MathWindowPrivate);
+ gtk_window_set_title(GTK_WINDOW(window),
+ /* Title of main window */
+ _("Calculator"));
+ gtk_window_set_icon_name(GTK_WINDOW(window), "accessories-calculator");
+ gtk_window_set_role(GTK_WINDOW(window), "gcalctool");
+ gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
+ g_signal_connect_after(G_OBJECT(window), "key-press-event", G_CALLBACK(key_press_cb), NULL);
+ g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(delete_cb), NULL);
+}
diff --git a/src/math-window.h b/src/math-window.h
new file mode 100644
index 0000000..70c81bd
--- /dev/null
+++ b/src/math-window.h
@@ -0,0 +1,61 @@
+/* Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef MATH_WINDOW_H
+#define MATH_WINDOW_H
+
+#include <glib-object.h>
+#include "math-equation.h"
+#include "math-display.h"
+#include "math-buttons.h"
+
+G_BEGIN_DECLS
+
+#define MATH_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), math_window_get_type(), MathWindow))
+
+typedef struct MathWindowPrivate MathWindowPrivate;
+
+typedef struct
+{
+ GtkWindow parent_instance;
+ MathWindowPrivate *priv;
+} MathWindow;
+
+typedef struct
+{
+ GtkWindowClass parent_class;
+
+ void (*quit)(MathWindow *window);
+} MathWindowClass;
+
+GType math_window_get_type(void);
+
+MathWindow *math_window_new(MathEquation *equation);
+
+GtkWidget *math_window_get_menu_bar(MathWindow *window);
+
+MathEquation *math_window_get_equation(MathWindow *window);
+
+MathDisplay *math_window_get_display(MathWindow *window);
+
+MathButtons *math_window_get_buttons(MathWindow *window);
+
+void math_window_critical_error(MathWindow *window, const gchar *title, const gchar *contents);
+
+#endif /* MATH_WINDOW_H */
diff --git a/src/mp-binary.c b/src/mp-binary.c
new file mode 100644
index 0000000..e4cedba
--- /dev/null
+++ b/src/mp-binary.c
@@ -0,0 +1,208 @@
+/* Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <stdio.h>
+
+#include "mp.h"
+#include "mp-private.h"
+
+// FIXME: Make dynamic
+#define MAX_DIGITS 1000
+
+static char digits[] = "0123456789ABCDEF";
+
+static int hex_to_int(char digit)
+{
+ if (digit >= '0' && digit <= '9')
+ return digit - '0';
+ if (digit >= 'A' && digit <= 'F')
+ return digit - 'A' + 10;
+ if (digit >= 'a' && digit <= 'f')
+ return digit - 'a' + 10;
+ return 0;
+}
+
+
+static void
+mp_bitwise(const MPNumber *x, const MPNumber *y, int (*bitwise_operator)(int, int), MPNumber *z, int wordlen)
+{
+ char text1[MAX_DIGITS], text2[MAX_DIGITS], text_out[MAX_DIGITS], text_out2[MAX_DIGITS];
+ int offset1, offset2, offset_out;
+
+ mp_cast_to_string(x, 16, 16, 0, 0, text1, MAX_DIGITS);
+ mp_cast_to_string(y, 16, 16, 0, 0, text2, MAX_DIGITS);
+ offset1 = strlen(text1) - 1;
+ offset2 = strlen(text2) - 1;
+ offset_out = wordlen / 4 - 1;
+ if (offset_out <= 0) {
+ offset_out = offset1 > offset2 ? offset1 : offset2;
+ }
+ if (offset_out > 0 && (offset_out < offset1 || offset_out < offset2)) {
+ mperr("Overflow. Try a bigger word size");
+ return;
+ }
+
+ /* Perform bitwise operator on each character from right to left */
+ for (text_out[offset_out+1] = '\0'; offset_out >= 0; offset_out--) {
+ int v1 = 0, v2 = 0;
+
+ if (offset1 >= 0) {
+ v1 = hex_to_int(text1[offset1]);
+ offset1--;
+ }
+ if (offset2 >= 0) {
+ v2 = hex_to_int(text2[offset2]);
+ offset2--;
+ }
+ text_out[offset_out] = digits[bitwise_operator(v1, v2)];
+ }
+
+ snprintf(text_out2, MAX_DIGITS, "%s", text_out);
+ mp_set_from_string(text_out2, 16, z);
+}
+
+
+static int mp_bitwise_and(int v1, int v2) { return v1 & v2; }
+static int mp_bitwise_or(int v1, int v2) { return v1 | v2; }
+static int mp_bitwise_xor(int v1, int v2) { return v1 ^ v2; }
+static int mp_bitwise_not(int v1, int dummy) { return v1 ^ 0xF; }
+
+
+bool
+mp_is_overflow (const MPNumber *x, int wordlen)
+{
+ MPNumber tmp1, tmp2;
+ mp_set_from_integer(2, &tmp1);
+ mp_xpowy_integer(&tmp1, wordlen, &tmp2);
+ return mp_is_greater_than (&tmp2, x);
+}
+
+
+void
+mp_and(const MPNumber *x, const MPNumber *y, MPNumber *z)
+{
+ if (!mp_is_positive_integer(x) || !mp_is_positive_integer(y))
+ {
+ /* Translators: Error displayed when boolean AND attempted on non-integer values */
+ mperr(_("Boolean AND is only defined for positive integers"));
+ }
+
+ mp_bitwise(x, y, mp_bitwise_and, z, 0);
+}
+
+
+void
+mp_or(const MPNumber *x, const MPNumber *y, MPNumber *z)
+{
+ if (!mp_is_positive_integer(x) || !mp_is_positive_integer(y))
+ {
+ /* Translators: Error displayed when boolean OR attempted on non-integer values */
+ mperr(_("Boolean OR is only defined for positive integers"));
+ }
+
+ mp_bitwise(x, y, mp_bitwise_or, z, 0);
+}
+
+
+void
+mp_xor(const MPNumber *x, const MPNumber *y, MPNumber *z)
+{
+ if (!mp_is_positive_integer(x) || !mp_is_positive_integer(y))
+ {
+ /* Translators: Error displayed when boolean XOR attempted on non-integer values */
+ mperr(_("Boolean XOR is only defined for positive integers"));
+ }
+
+ mp_bitwise(x, y, mp_bitwise_xor, z, 0);
+}
+
+
+void
+mp_not(const MPNumber *x, int wordlen, MPNumber *z)
+{
+ MPNumber temp;
+
+ if (!mp_is_positive_integer(x))
+ {
+ /* Translators: Error displayed when boolean XOR attempted on non-integer values */
+ mperr(_("Boolean NOT is only defined for positive integers"));
+ }
+
+ mp_set_from_integer(0, &temp);
+ mp_bitwise(x, &temp, mp_bitwise_not, z, wordlen);
+}
+
+
+void
+mp_mask(const MPNumber *x, int wordlen, MPNumber *z)
+{
+ char text[MAX_DIGITS];
+ size_t len, offset;
+
+ /* Convert to a hexadecimal string and use last characters */
+ mp_cast_to_string(x, 16, 16, 0, 0, text, MAX_DIGITS);
+ len = strlen(text);
+ offset = wordlen / 4;
+ offset = len > offset ? len - offset: 0;
+ mp_set_from_string(text + offset, 16, z);
+}
+
+
+void
+mp_shift(const MPNumber *x, int count, MPNumber *z)
+{
+ int i, multiplier = 1;
+
+ if (!mp_is_integer(x)) {
+ /* Translators: Error displayed when bit shift attempted on non-integer values */
+ mperr(_("Shift is only possible on integer values"));
+ return;
+ }
+
+ if (count >= 0) {
+ for (i = 0; i < count; i++)
+ multiplier *= 2;
+ mp_multiply_integer(x, multiplier, z);
+ }
+ else {
+ MPNumber temp;
+ for (i = 0; i < -count; i++)
+ multiplier *= 2;
+ mp_divide_integer(x, multiplier, &temp);
+ mp_floor(&temp, z);
+ }
+}
+
+
+void
+mp_ones_complement(const MPNumber *x, int wordlen, MPNumber *z)
+{
+ MPNumber t;
+ mp_set_from_integer(0, &t);
+ mp_bitwise(x, &t, mp_bitwise_xor, z, wordlen);
+ mp_not(z, wordlen, z);
+}
+
+
+void
+mp_twos_complement(const MPNumber *x, int wordlen, MPNumber *z)
+{
+ mp_ones_complement (x, wordlen, z);
+ mp_add_integer (z, 1, z);
+}
diff --git a/src/mp-convert.c b/src/mp-convert.c
new file mode 100644
index 0000000..68be574
--- /dev/null
+++ b/src/mp-convert.c
@@ -0,0 +1,933 @@
+/* Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+
+#include "mp.h"
+#include "mp-private.h"
+
+void
+mp_set_from_mp(const MPNumber *x, MPNumber *z)
+{
+ if (z != x)
+ memcpy(z, x, sizeof(MPNumber));
+}
+
+
+void
+mp_set_from_float(float rx, MPNumber *z)
+{
+ int i, k, ib, ie, tp;
+ float rj;
+
+ mp_set_from_integer(0, z);
+
+ /* CHECK SIGN */
+ if (rx < 0.0f) {
+ z->sign = -1;
+ rj = -(double)(rx);
+ } else if (rx > 0.0f) {
+ z->sign = 1;
+ rj = rx;
+ } else {
+ /* IF RX = 0E0 RETURN 0 */
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* INCREASE IE AND DIVIDE RJ BY 16. */
+ ie = 0;
+ while (rj >= 1.0f) {
+ ++ie;
+ rj *= 0.0625f;
+ }
+ while (rj < 0.0625f) {
+ --ie;
+ rj *= 16.0f;
+ }
+
+ /* NOW RJ IS DY DIVIDED BY SUITABLE POWER OF 16.
+ * SET EXPONENT TO 0
+ */
+ z->exponent = 0;
+
+ /* CONVERSION LOOP (ASSUME SINGLE-PRECISION OPS. EXACT) */
+ for (i = 0; i < MP_T + 4; i++) {
+ rj *= (float) MP_BASE;
+ z->fraction[i] = (int) rj;
+ rj -= (float) z->fraction[i];
+ }
+
+ /* NORMALIZE RESULT */
+ mp_normalize(z);
+
+ /* Computing MAX */
+ ib = max(MP_BASE * 7 * MP_BASE, 32767) / 16;
+ tp = 1;
+
+ /* NOW MULTIPLY BY 16**IE */
+ if (ie < 0) {
+ k = -ie;
+ for (i = 1; i <= k; ++i) {
+ tp <<= 4;
+ if (tp <= ib && tp != MP_BASE && i < k)
+ continue;
+ mp_divide_integer(z, tp, z);
+ tp = 1;
+ }
+ } else if (ie > 0) {
+ for (i = 1; i <= ie; ++i) {
+ tp <<= 4;
+ if (tp <= ib && tp != MP_BASE && i < ie)
+ continue;
+ mp_multiply_integer(z, tp, z);
+ tp = 1;
+ }
+ }
+}
+
+
+void
+mp_set_from_double(double dx, MPNumber *z)
+{
+ int i, k, ib, ie, tp;
+ double dj;
+
+ mp_set_from_integer(0, z);
+
+ /* CHECK SIGN */
+ if (dx < 0.0) {
+ z->sign = -1;
+ dj = -dx;
+ } else if (dx > 0.0) {
+ z->sign = 1;
+ dj = dx;
+ } else {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* INCREASE IE AND DIVIDE DJ BY 16. */
+ for (ie = 0; dj >= 1.0; ie++)
+ dj *= 1.0/16.0;
+
+ for ( ; dj < 1.0/16.0; ie--)
+ dj *= 16.0;
+
+ /* NOW DJ IS DY DIVIDED BY SUITABLE POWER OF 16
+ * SET EXPONENT TO 0
+ */
+ z->exponent = 0;
+
+ /* CONVERSION LOOP (ASSUME DOUBLE-PRECISION OPS. EXACT) */
+ for (i = 0; i < MP_T + 4; i++) {
+ dj *= (double) MP_BASE;
+ z->fraction[i] = (int) dj;
+ dj -= (double) z->fraction[i];
+ }
+
+ /* NORMALIZE RESULT */
+ mp_normalize(z);
+
+ /* Computing MAX */
+ ib = max(MP_BASE * 7 * MP_BASE, 32767) / 16;
+ tp = 1;
+
+ /* NOW MULTIPLY BY 16**IE */
+ if (ie < 0) {
+ k = -ie;
+ for (i = 1; i <= k; ++i) {
+ tp <<= 4;
+ if (tp <= ib && tp != MP_BASE && i < k)
+ continue;
+ mp_divide_integer(z, tp, z);
+ tp = 1;
+ }
+ } else if (ie > 0) {
+ for (i = 1; i <= ie; ++i) {
+ tp <<= 4;
+ if (tp <= ib && tp != MP_BASE && i < ie)
+ continue;
+ mp_multiply_integer(z, tp, z);
+ tp = 1;
+ }
+ }
+}
+
+
+void
+mp_set_from_integer(int64_t x, MPNumber *z)
+{
+ int i;
+
+ memset(z, 0, sizeof(MPNumber));
+
+ if (x == 0) {
+ z->sign = 0;
+ return;
+ }
+
+ if (x < 0) {
+ x = -x;
+ z->sign = -1;
+ }
+ else if (x > 0)
+ z->sign = 1;
+
+ while (x != 0) {
+ z->fraction[z->exponent] = x % MP_BASE;
+ z->exponent++;
+ x /= MP_BASE;
+ }
+ for (i = 0; i < z->exponent / 2; i++) {
+ int t = z->fraction[i];
+ z->fraction[i] = z->fraction[z->exponent - i - 1];
+ z->fraction[z->exponent - i - 1] = t;
+ }
+}
+
+
+void
+mp_set_from_unsigned_integer(uint64_t x, MPNumber *z)
+{
+ int i;
+
+ mp_set_from_integer(0, z);
+
+ if (x == 0) {
+ z->sign = 0;
+ return;
+ }
+ z->sign = 1;
+
+ while (x != 0) {
+ z->fraction[z->exponent] = x % MP_BASE;
+ x = x / MP_BASE;
+ z->exponent++;
+ }
+ for (i = 0; i < z->exponent / 2; i++) {
+ int t = z->fraction[i];
+ z->fraction[i] = z->fraction[z->exponent - i - 1];
+ z->fraction[z->exponent - i - 1] = t;
+ }
+}
+
+
+void
+mp_set_from_fraction(int64_t numerator, int64_t denominator, MPNumber *z)
+{
+ mp_gcd(&numerator, &denominator);
+
+ if (denominator == 0) {
+ mperr("*** J == 0 IN CALL TO MP_SET_FROM_FRACTION ***\n");
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ if (denominator < 0) {
+ numerator = -numerator;
+ denominator = -denominator;
+ }
+
+ mp_set_from_integer(numerator, z);
+ if (denominator != 1)
+ mp_divide_integer(z, denominator, z);
+}
+
+
+void
+mp_set_from_polar(const MPNumber *r, MPAngleUnit unit, const MPNumber *theta, MPNumber *z)
+{
+ MPNumber x, y;
+
+ mp_cos(theta, unit, &x);
+ mp_multiply(&x, r, &x);
+ mp_sin(theta, unit, &y);
+ mp_multiply(&y, r, &y);
+ mp_set_from_complex(&x, &y, z);
+}
+
+
+void
+mp_set_from_complex(const MPNumber *x, const MPNumber *y, MPNumber *z)
+{
+ /* NOTE: Do imaginary component first as z may be x or y */
+ z->im_sign = y->sign;
+ z->im_exponent = y->exponent;
+ memcpy(z->im_fraction, y->fraction, sizeof(int) * MP_SIZE);
+
+ z->sign = x->sign;
+ z->exponent = x->exponent;
+ if (z != x)
+ memcpy(z->fraction, x->fraction, sizeof(int) * MP_SIZE);
+}
+
+
+void
+mp_set_from_random(MPNumber *z)
+{
+ mp_set_from_double(drand48(), z);
+}
+
+
+int64_t
+mp_cast_to_int(const MPNumber *x)
+{
+ int i;
+ int64_t z = 0, v;
+ 
+ /* |x| <= 1 */
+ if (x->sign == 0 || x->exponent <= 0)
+ return 0;
+
+ /* Multiply digits together */
+ for (i = 0; i < x->exponent; i++) {
+ int64_t t;
+
+ t = z;
+ z = z * MP_BASE + x->fraction[i];
+ 
+ /* Check for overflow */
+ if (z <= t)
+ return 0;
+ }
+
+ /* Validate result */
+ v = z;
+ for (i = x->exponent - 1; i >= 0; i--) {
+ int64_t digit;
+
+ /* Get last digit */
+ digit = v - (v / MP_BASE) * MP_BASE;
+ if (x->fraction[i] != digit)
+ return 0;
+
+ v /= MP_BASE;
+ }
+ if (v != 0)
+ return 0;
+
+ return x->sign * z;
+}
+
+
+uint64_t
+mp_cast_to_unsigned_int(const MPNumber *x)
+{
+ int i;
+ uint64_t z = 0, v;
+ 
+ /* x <= 1 */
+ if (x->sign <= 0 || x->exponent <= 0)
+ return 0;
+
+ /* Multiply digits together */
+ for (i = 0; i < x->exponent; i++) {
+ uint64_t t;
+
+ t = z;
+ z = z * MP_BASE + x->fraction[i];
+ 
+ /* Check for overflow */
+ if (z <= t)
+ return 0;
+ }
+
+ /* Validate result */
+ v = z;
+ for (i = x->exponent - 1; i >= 0; i--) {
+ uint64_t digit;
+
+ /* Get last digit */
+ digit = v - (v / MP_BASE) * MP_BASE;
+ if (x->fraction[i] != digit)
+ return 0;
+
+ v /= MP_BASE;
+ }
+ if (v != 0)
+ return 0;
+
+ return z;
+}
+
+
+static double
+mppow_ri(float ap, int bp)
+{
+ double pow;
+
+ if (bp == 0)
+ return 1.0;
+
+ if (bp < 0) {
+ if (ap == 0)
+ return 1.0;
+ bp = -bp;
+ ap = 1 / ap;
+ }
+
+ pow = 1.0;
+ for (;;) {
+ if (bp & 01)
+ pow *= ap;
+ if (bp >>= 1)
+ ap *= ap;
+ else
+ break;
+ }
+
+ return pow;
+}
+
+
+float
+mp_cast_to_float(const MPNumber *x)
+{
+ int i;
+ float rz = 0.0;
+
+ if (mp_is_zero(x))
+ return 0.0;
+
+ for (i = 0; i < MP_T; i++) {
+ rz = (float) MP_BASE * rz + (float)x->fraction[i];
+
+ /* CHECK IF FULL SINGLE-PRECISION ACCURACY ATTAINED */
+ if (rz + 1.0f <= rz)
+ break;
+ }
+
+ /* NOW ALLOW FOR EXPONENT */
+ rz *= mppow_ri((float) MP_BASE, x->exponent - i - 1);
+
+ /* CHECK REASONABLENESS OF RESULT */
+ /* LHS SHOULD BE <= 0.5, BUT ALLOW FOR SOME ERROR IN ALOG */
+ if (rz <= (float)0. ||
+ fabs((float) x->exponent - (log(rz) / log((float) MP_BASE) + (float).5)) > (float).6) {
+ /* FOLLOWING MESSAGE INDICATES THAT X IS TOO LARGE OR SMALL -
+ * TRY USING MPCMRE INSTEAD.
+ */
+ mperr("*** FLOATING-POINT OVER/UNDER-FLOW IN MP_CAST_TO_FLOAT ***\n");
+ return 0.0;
+ }
+
+ if (x->sign < 0)
+ rz = -(double)(rz);
+
+ return rz;
+}
+
+
+static double
+mppow_di(double ap, int bp)
+{
+ double pow = 1.0;
+
+ if (bp != 0) {
+ if (bp < 0) {
+ if (ap == 0) return(pow);
+ bp = -bp;
+ ap = 1/ap;
+ }
+ for (;;) {
+ if (bp & 01) pow *= ap;
+ if (bp >>= 1) ap *= ap;
+ else break;
+ }
+ }
+
+ return(pow);
+}
+
+
+double
+mp_cast_to_double(const MPNumber *x)
+{
+ int i, tm = 0;
+ double d__1, dz2, ret_val = 0.0;
+
+ if (mp_is_zero(x))
+ return 0.0;
+
+ for (i = 0; i < MP_T; i++) {
+ ret_val = (double) MP_BASE * ret_val + (double) x->fraction[i];
+ tm = i;
+
+ /* CHECK IF FULL DOUBLE-PRECISION ACCURACY ATTAINED */
+ dz2 = ret_val + 1.0;
+
+ /* TEST BELOW NOT ALWAYS EQUIVALENT TO - IF (DZ2.LE.DZ) GO TO 20,
+ * FOR EXAMPLE ON CYBER 76.
+ */
+ if (dz2 - ret_val <= 0.0)
+ break;
+ }
+
+ /* NOW ALLOW FOR EXPONENT */
+ ret_val *= mppow_di((double) MP_BASE, x->exponent - tm - 1);
+
+ /* CHECK REASONABLENESS OF RESULT. */
+ /* LHS SHOULD BE .LE. 0.5 BUT ALLOW FOR SOME ERROR IN DLOG */
+ if (ret_val <= 0. ||
+ ((d__1 = (double) ((float) x->exponent) - (log(ret_val) / log((double)
+ ((float) MP_BASE)) + .5), abs(d__1)) > .6)) {
+ /* FOLLOWING MESSAGE INDICATES THAT X IS TOO LARGE OR SMALL -
+ * TRY USING MPCMDE INSTEAD.
+ */
+ mperr("*** FLOATING-POINT OVER/UNDER-FLOW IN MP_CAST_TO_DOUBLE ***\n");
+ return 0.0;
+ }
+ else
+ {
+ if (x->sign < 0)
+ ret_val = -ret_val;
+ return ret_val;
+ }
+}
+
+
+static void
+mp_cast_to_string_real(const MPNumber *x, int default_base, int base, int accuracy, bool trim_zeroes, bool force_sign, GString *string)
+{
+ static char digits[] = "0123456789ABCDEF";
+ MPNumber number, integer_component, fractional_component, temp;
+ int i, last_non_zero;
+
+ if (mp_is_negative(x))
+ mp_abs(x, &number);
+ else
+ mp_set_from_mp(x, &number);
+
+ /* Add rounding factor */
+ mp_set_from_integer(base, &temp);
+ mp_xpowy_integer(&temp, -(accuracy+1), &temp);
+ mp_multiply_integer(&temp, base, &temp);
+ mp_divide_integer(&temp, 2, &temp);
+ mp_add(&number, &temp, &number);
+
+ /* Split into integer and fractional component */
+ mp_floor(&number, &integer_component);
+ mp_fractional_component(&number, &fractional_component);
+
+ /* Write out the integer component least significant digit to most */
+ mp_set_from_mp(&integer_component, &temp);
+ do {
+ MPNumber t, t2, t3;
+ int64_t d;
+
+ mp_divide_integer(&temp, base, &t);
+ mp_floor(&t, &t);
+ mp_multiply_integer(&t, base, &t2);
+
+ mp_subtract(&temp, &t2, &t3);
+
+ d = mp_cast_to_int(&t3);
+ g_string_prepend_c(string, d < 16 ? digits[d] : '?');
+
+ mp_set_from_mp(&t, &temp);
+ } while (!mp_is_zero(&temp));
+
+ last_non_zero = string->len;
+ g_string_append_c(string, '.');
+
+ /* Write out the fractional component */
+ mp_set_from_mp(&fractional_component, &temp);
+ for (i = accuracy; i > 0 && !mp_is_zero(&temp); i--) {
+ int d;
+ MPNumber digit;
+
+ mp_multiply_integer(&temp, base, &temp);
+ mp_floor(&temp, &digit);
+ d = mp_cast_to_int(&digit);
+
+ g_string_append_c(string, digits[d]);
+
+ if(d != 0)
+ last_non_zero = string->len;
+ mp_subtract(&temp, &digit, &temp);
+ }
+
+ /* Strip trailing zeroes */
+ if (trim_zeroes || accuracy == 0)
+ g_string_truncate(string, last_non_zero);
+
+ /* Add sign on non-zero values */
+ if (strcmp(string->str, "0") != 0 || force_sign) {
+ if (mp_is_negative(x))
+ g_string_prepend(string, "−");
+ else if (force_sign)
+ g_string_prepend(string, "+");
+ }
+
+ /* Append base suffix if not in default base */
+ if (base != default_base) {
+ const char *digits[] = {"₀", "₁", "₂", "₃", "₄", "₅", "₆", "₇", "₈", "₉"};
+ int multiplier = 1;
+ int b = base;
+
+ while (base / multiplier != 0)
+ multiplier *= 10;
+ while (multiplier != 1) {
+ int d;
+ multiplier /= 10;
+ d = b / multiplier;
+ g_string_append(string, digits[d]);
+ b -= d * multiplier;
+ }
+ }
+}
+
+
+void
+mp_cast_to_string(const MPNumber *x, int default_base, int base, int accuracy, bool trim_zeroes, char *buffer, int buffer_length)
+{
+ GString *string;
+ MPNumber x_real;
+
+ string = g_string_sized_new(buffer_length);
+
+ mp_real_component(x, &x_real);
+ mp_cast_to_string_real(&x_real, default_base, base, accuracy, trim_zeroes, FALSE, string);
+ if (mp_is_complex(x)) {
+ GString *s;
+ gboolean force_sign = TRUE;
+ MPNumber x_im;
+
+ mp_imaginary_component(x, &x_im);
+
+ if (strcmp(string->str, "0") == 0) {
+ g_string_assign(string, "");
+ force_sign = false;
+ }
+
+ s = g_string_sized_new(buffer_length);
+ mp_cast_to_string_real(&x_im, default_base, 10, accuracy, trim_zeroes, force_sign, s);
+ if (strcmp(s->str, "0") == 0 || strcmp(s->str, "+0") == 0 || strcmp(s->str, "−0") == 0) {
+ /* Ignore */
+ }
+ else if (strcmp(s->str, "1") == 0) {
+ g_string_append(string, "i");
+ }
+ else if (strcmp(s->str, "+1") == 0) {
+ g_string_append(string, "+i");
+ }
+ else if (strcmp(s->str, "−1") == 0) {
+ g_string_append(string, "−i");
+ }
+ else {
+ if (strcmp(s->str, "+0") == 0)
+ g_string_append(string, "+");
+ else if (strcmp(s->str, "0") != 0)
+ g_string_append(string, s->str);
+
+ g_string_append(string, "i");
+ }
+ g_string_free(s, TRUE);
+ }
+
+ // FIXME: Check for truncation
+ strncpy(buffer, string->str, buffer_length);
+ g_string_free(string, TRUE);
+}
+
+
+void
+mp_cast_to_exponential_string(const MPNumber *x, int default_base, int base_, int max_digits, bool trim_zeroes, bool eng_format, char *buffer, int buffer_length)
+{
+ char fixed[1024], *c;
+ MPNumber t, z, base, base3, base10, base10inv, mantissa;
+ int exponent = 0;
+ GString *string;
+ const char *super_digits[] = {"⁰", "¹", "²", "³", "⁴", "⁵", "⁶", "⁷", "⁸", "⁹"};
+
+ string = g_string_sized_new(buffer_length);
+
+ mp_abs(x, &z);
+ if (mp_is_negative(x))
+ g_string_append(string, "−");
+ mp_set_from_mp(&z, &mantissa);
+
+ mp_set_from_integer(base_, &base);
+ mp_xpowy_integer(&base, 3, &base3);
+ mp_xpowy_integer(&base, 10, &base10);
+ mp_set_from_integer(1, &t);
+ mp_divide(&t, &base10, &base10inv);
+
+ if (!mp_is_zero(&mantissa)) {
+ while (!eng_format && mp_is_greater_equal(&mantissa, &base10)) {
+ exponent += 10;
+ mp_multiply(&mantissa, &base10inv, &mantissa);
+ }
+
+ while ((!eng_format && mp_is_greater_equal(&mantissa, &base)) ||
+ (eng_format && (mp_is_greater_equal(&mantissa, &base3) || exponent % 3 != 0))) {
+ exponent += 1;
+ mp_divide(&mantissa, &base, &mantissa);
+ }
+
+ while (!eng_format && mp_is_less_than(&mantissa, &base10inv)) {
+ exponent -= 10;
+ mp_multiply(&mantissa, &base10, &mantissa);
+ }
+
+ mp_set_from_integer(1, &t);
+ while (mp_is_less_than(&mantissa, &t) || (eng_format && exponent % 3 != 0)) {
+ exponent -= 1;
+ mp_multiply(&mantissa, &base, &mantissa);
+ }
+ }
+
+ mp_cast_to_string(&mantissa, default_base, base_, max_digits, trim_zeroes, fixed, 1024);
+ g_string_append(string, fixed);
+ if (exponent != 0) {
+ g_string_append_printf(string, "×10"); // FIXME: Use the current base
+ if (exponent < 0) {
+ exponent = -exponent;
+ g_string_append(string, "⁻");
+ }
+ snprintf(fixed, 1024, "%d", exponent);
+ for (c = fixed; *c; c++)
+ g_string_append(string, super_digits[*c - '0']);
+ }
+
+ strncpy(buffer, string->str, buffer_length);
+ g_string_free(string, TRUE);
+}
+
+
+static int
+char_val(char **c, int base)
+{
+ int i, j, value, offset;
+ const char *digits[][10] = {{"٠", "١", "٢", "٣", "٤", "٥", "٦", "٧", "٨", "٩"},
+ {"۰", "۱", "۲", "۳", "۴", "۵", "۶", "۷", "۸", "۹"},
+ {"߀", "߁", "߂", "߃", "߄", "߅", "߆", "߇", "߈", "߉"},
+ {"०", "१", "२", "३", "४", "५", "६", "७", "८", "९"},
+ {"০", "১", "২", "৩", "৪", "৫", "৬", "৭", "৮", "৯"},
+ {"੦", "੧", "੨", "੩", "੪", "੫", "੬", "੭", "੮", "੯"},
+ {"૦", "૧", "૨", "૩", "૪", "૫", "૬", "૭", "૮", "૯"},
+ {"୦", "୧", "୨", "୩", "୪", "୫", "୬", "୭", "୮", "୯"},
+ {"௦", "௧", "௨", "௩", "௪", "௫", "௬", "௭", "௮", "௯"},
+ {"౦", "౧", "౨", "౩", "౪", "౫", "౬", "౭", "౮", "౯"},
+ {"೦", "೧", "೨", "೩", "೪", "೫", "೬", "೭", "೮", "೯"},
+ {"൦", "൧", "൨", "൩", "൪", "൫", "൬", "൭", "൮", "൯"},
+ {"๐", "๑", "๒", "๓", "๔", "๕", "๖", "๗", "๘", "๙"},
+ {"໐", "໑", "໒", "໓", "໔", "໕", "໖", "໗", "໘", "໙"},
+ {"༠", "༡", "༢", "༣", "༤", "༥", "༦", "༧", "༨", "༩"},
+ {"၀", "၁", "၂", "၃", "၄", "၅", "၆", "၇", "၈", "၉"},
+ {"႐", "႑", "႒", "႓", "႔", "႕", "႖", "႗", "႘", "႙"},
+ {"០", "១", "២", "៣", "៤", "៥", "៦", "៧", "៨", "៩"},
+ {"᠐", "᠑", "᠒", "᠓", "᠔", "᠕", "᠖", "᠗", "᠘", "᠙"},
+ {"᥆", "᥇", "᥈", "᥉", "᥊", "᥋", "᥌", "᥍", "᥎", "᥏"},
+ {"᧐", "᧑", "᧒", "᧓", "᧔", "᧕", "᧖", "᧗", "᧘", "᧙"},
+ {"᭐", "᭑", "᭒", "᭓", "᭔", "᭕", "᭖", "᭗", "᭘", "᭙"},
+ {"᮰", "᮱", "᮲", "᮳", "᮴", "᮵", "᮶", "᮷", "᮸", "᮹"},
+ {"᱀", "᱁", "᱂", "᱃", "᱄", "᱅", "᱆", "᱇", "᱈", "᱉"},
+ {"᱐", "᱑", "᱒", "᱓", "᱔", "᱕", "᱖", "᱗", "᱘", "᱙"},
+ {"꘠", "꘡", "꘢", "꘣", "꘤", "꘥", "꘦", "꘧", "꘨", "꘩"},
+ {"꣐", "꣑", "꣒", "꣓", "꣔", "꣕", "꣖", "꣗", "꣘", "꣙"},
+ {"꤀", "꤁", "꤂", "꤃", "꤄", "꤅", "꤆", "꤇", "꤈", "꤉"},
+ {"꩐", "꩑", "꩒", "꩓", "꩔", "꩕", "꩖", "꩗", "꩘", "꩙"},
+ {"𐒠", "𐒡", "𐒢", "𐒣", "𐒤", "𐒥", "𐒦", "𐒧", "𐒨", "𐒩"},
+ {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL}};
+
+ if (**c >= '0' && **c <= '9') {
+ value = **c - '0';
+ offset = 1;
+ } else if (**c >= 'a' && **c <= 'f') {
+ value = **c - 'a' + 10;
+ offset = 1;
+ } else if (**c >= 'A' && **c <= 'F') {
+ value = **c - 'A' + 10;
+ offset = 1;
+ } else {
+ for (i = 0; digits[i][0]; i++) {
+ for (j = 0; j < 10; j++) {
+ if (strncmp(*c, digits[i][j], strlen(digits[i][j])) == 0)
+ break;
+ }
+ if (j != 10)
+ break;
+ }
+ if (digits[i][0] == NULL)
+ return -1;
+ value = j;
+ offset = strlen(digits[i][j]);
+ }
+ if (value >= base)
+ return -1;
+
+ *c += offset;
+
+ return value;
+}
+
+
+static int
+ends_with(const char *start, const char *end, const char *word)
+{
+ size_t word_len = strlen(word);
+
+ if (word_len > end - start)
+ return 0;
+
+ return strncmp(end - word_len, word, word_len) == 0;
+}
+
+
+// FIXME: Doesn't handle errors well (e.g. trailing space)
+static bool
+set_from_sexagesimal(const char *str, int length, MPNumber *z)
+{
+ int degrees = 0, minutes = 0;
+ char seconds[length+1];
+ MPNumber t;
+ int n_matched;
+
+ seconds[0] = '\0';
+ n_matched = sscanf(str, "%d°%d'%s\"", &degrees, &minutes, seconds);
+
+ if (n_matched < 1)
+ return true;
+ mp_set_from_integer(degrees, z);
+ if (n_matched > 1) {
+ mp_set_from_integer(minutes, &t);
+ mp_divide_integer(&t, 60, &t);
+ mp_add(z, &t, z);
+ }
+ if (n_matched > 2) {
+ mp_set_from_string(seconds, 10, &t);
+ mp_divide_integer(&t, 3600, &t);
+ mp_add(z, &t, z);
+ }
+
+ return false;
+}
+
+
+bool
+mp_set_from_string(const char *str, int default_base, MPNumber *z)
+{
+ int i, base, negate = 0, multiplier = 0, base_multiplier = 1;
+ const char *c, *end;
+ gboolean has_fraction = FALSE;
+
+ const char *base_digits[] = {"₀", "₁", "₂", "₃", "₄", "₅", "₆", "₇", "₈", "₉", NULL};
+ const char *fractions[] = {"½", "⅓", "⅔", "¼", "¾", "⅕", "⅖", "⅗", "⅘", "⅙", "⅚", "⅛", "⅜", "⅝", "⅞", NULL};
+ int numerators[] = { 1, 1, 2, 1, 3, 1, 2, 3, 4, 1, 5, 1, 3, 5, 7};
+ int denominators[] = { 2, 3, 3, 4, 4, 5, 5, 5, 5, 6, 6, 8, 8, 8, 8};
+ 
+ if (strstr(str, "°"))
+ return set_from_sexagesimal(str, strlen(str), z);
+
+ /* Find the base */
+ end = str;
+ while (*end != '\0')
+ end++;
+ base = 0;
+ while (1) {
+ for (i = 0; base_digits[i] != NULL; i++) {
+ if (ends_with(str, end, base_digits[i])) {
+ base += i * base_multiplier;
+ end -= strlen(base_digits[i]);
+ base_multiplier *= 10;
+ break;
+ }
+ }
+ if (base_digits[i] == NULL)
+ break;
+ }
+ if (base_multiplier == 1)
+ base = default_base;
+
+ /* Check if this has a sign */
+ c = str;
+ if (*c == '+') {
+ c++;
+ } else if (*c == '-') {
+ negate = 1;
+ c++;
+ } else if (strncmp(c, "−", strlen("−")) == 0) {
+ negate = 1;
+ c += strlen("−");
+ }
+
+ /* Convert integer part */
+ mp_set_from_integer(0, z);
+ while ((i = char_val((char **)&c, base)) >= 0) {
+ if (i > base)
+ return true;
+ mp_multiply_integer(z, base, z);
+ mp_add_integer(z, i, z);
+ }
+
+ /* Look for fraction characters, e.g. ⅚ */
+ for (i = 0; fractions[i] != NULL; i++) {
+ if (ends_with(str, end, fractions[i])) {
+ end -= strlen(fractions[i]);
+ break;
+ }
+ }
+ if (fractions[i] != NULL) {
+ MPNumber fraction;
+ mp_set_from_fraction(numerators[i], denominators[i], &fraction);
+ mp_add(z, &fraction, z);
+ }
+
+ if (*c == '.' || *c == ',') {
+ has_fraction = TRUE;
+ c++;
+ }
+
+ /* Convert fractional part */
+ if (has_fraction) {
+ MPNumber numerator, denominator;
+
+ mp_set_from_integer(0, &numerator);
+ mp_set_from_integer(1, &denominator);
+ while ((i = char_val((char **)&c, base)) >= 0) {
+ mp_multiply_integer(&denominator, base, &denominator);
+ mp_multiply_integer(&numerator, base, &numerator);
+ mp_add_integer(&numerator, i, &numerator);
+ }
+ mp_divide(&numerator, &denominator, &numerator);
+ mp_add(z, &numerator, z);
+ }
+
+ if (c != end) {
+ return true;
+ }
+
+ if (multiplier != 0) {
+ MPNumber t;
+ mp_set_from_integer(10, &t);
+ mp_xpowy_integer(&t, multiplier, &t);
+ mp_multiply(z, &t, z);
+ }
+
+ if (negate == 1)
+ mp_invert_sign(z, z);
+
+ return false;
+}
diff --git a/src/mp-equation-lexer.l b/src/mp-equation-lexer.l
new file mode 100644
index 0000000..bbc9765
--- /dev/null
+++ b/src/mp-equation-lexer.l
@@ -0,0 +1,120 @@
+%option 8bit reentrant bison-locations
+%option never-interactive
+%option noyywrap noinput nounput
+%option prefix="_mp_equation_"
+%option extra-type="MPEquationParserState *"
+%option outfile="mp-equation-lexer.c" header-file="mp-equation-lexer.h"
+
+%{
+/* Copyright (c) 2004-2008 Sami Pietila
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+#include <locale.h>
+#include <string.h>
+#include <sys/types.h>
+
+#include "mp-equation-private.h"
+#include "mp-equation-parser.h"
+#include "mp-equation.h"
+%}
+
+
+ZERO "0"|"٠"|"۰"|"߀"|"०"|"০"|"੦"|"૦"|"୦"|"௦"|"౦"|"೦"|"൦"|"๐"|"໐"|"༠"|"၀"|"႐"|"០"|"᠐"|"᥆"|"᧐"|"᭐"|"᮰"|"᱀"|"᱐"|"꘠"|"꣐"|"꤀"|"꩐"|"𐒠"
+ONE "1"|"١"|"۱"|"߁"|"१"|"১"|"੧"|"૧"|"୧"|"௧"|"౧"|"೧"|"൧"|"๑"|"໑"|"༡"|"၁"|"႑"|"១"|"᠑"|"᥇"|"᧑"|"᭑"|"᮱"|"᱁"|"᱑"|"꘡"|"꣑"|"꤁"|"꩑"|"𐒡"
+TWO "2"|"٢"|"۲"|"߂"|"२"|"২"|"੨"|"૨"|"୨"|"௨"|"౨"|"೨"|"൨"|"๒"|"໒"|"༢"|"၂"|"႒"|"២"|"᠒"|"᥈"|"᧒"|"᭒"|"᮲"|"᱂"|"᱒"|"꘢"|"꣒"|"꤂"|"꩒"|"𐒢"
+THREE "3"|"٣"|"۳"|"߃"|"३"|"৩"|"੩"|"૩"|"୩"|"௩"|"౩"|"೩"|"൩"|"๓"|"໓"|"༣"|"၃"|"႓"|"៣"|"᠓"|"᥉"|"᧓"|"᭓"|"᮳"|"᱃"|"᱓"|"꘣"|"꣓"|"꤃"|"꩓"|"𐒣"
+FOUR "4"|"٤"|"۴"|"߄"|"४"|"৪"|"੪"|"૪"|"୪"|"௪"|"౪"|"೪"|"൪"|"๔"|"໔"|"༤"|"၄"|"႔"|"៤"|"᠔"|"᥊"|"᧔"|"᭔"|"᮴"|"᱄"|"᱔"|"꘤"|"꣔"|"꤄"|"꩔"|"𐒤"
+FIVE "5"|"٥"|"۵"|"߅"|"५"|"৫"|"੫"|"૫"|"୫"|"௫"|"౫"|"೫"|"൫"|"๕"|"໕"|"༥"|"၅"|"႕"|"៥"|"᠕"|"᥋"|"᧕"|"᭕"|"᮵"|"᱅"|"᱕"|"꘥"|"꣕"|"꤅"|"꩕"|"𐒥"
+SIX "6"|"٦"|"۶"|"߆"|"६"|"৬"|"੬"|"૬"|"୬"|"௬"|"౬"|"೬"|"൬"|"๖"|"໖"|"༦"|"၆"|"႖"|"៦"|"᠖"|"᥌"|"᧖"|"᭖"|"᮶"|"᱆"|"᱖"|"꘦"|"꣖"|"꤆"|"꩖"|"𐒦"
+SEVEN "7"|"٧"|"۷"|"߇"|"७"|"৭"|"੭"|"૭"|"୭"|"௭"|"౭"|"೭"|"൭"|"๗"|"໗"|"༧"|"၇"|"႗"|"៧"|"᠗"|"᥍"|"᧗"|"᭗"|"᮷"|"᱇"|"᱗"|"꘧"|"꣗"|"꤇"|"꩗"|"𐒧"
+EIGHT "8"|"٨"|"۸"|"߈"|"८"|"৮"|"੮"|"૮"|"୮"|"௮"|"౮"|"೮"|"൮"|"๘"|"໘"|"༨"|"၈"|"႘"|"៨"|"᠘"|"᥎"|"᧘"|"᭘"|"᮸"|"᱈"|"᱘"|"꘨"|"꣘"|"꤈"|"꩘"|"𐒨"
+NINE "9"|"٩"|"۹"|"߉"|"९"|"৯"|"੯"|"૯"|"୯"|"௯"|"౯"|"೯"|"൯"|"๙"|"໙"|"༩"|"၉"|"႙"|"៩"|"᠙"|"᥏"|"᧙"|"᭙"|"᮹"|"᱉"|"᱙"|"꘩"|"꣙"|"꤉"|"꩙"|"𐒩"
+DECIMAL "."|","
+DEC {ZERO}|{ONE}|{TWO}|{THREE}|{FOUR}|{FIVE}|{SIX}|{SEVEN}|{EIGHT}|{NINE}
+HEX {DEC}|[A-F]|[a-f]
+SUPER_DIGITS "⁰"|"¹"|"²"|"³"|"⁴"|"⁵"|"⁶"|"⁷"|"⁸"|"⁹"
+SUPER_MINUS "⁻"
+SUB_DIGITS "₀"|"₁"|"₂"|"₃"|"₄"|"₅"|"₆"|"₇"|"₈"|"₉"
+FRACTION "½"|"⅓"|"⅔"|"¼"|"¾"|"⅕"|"⅖"|"⅗"|"⅘"|"⅙"|"⅚"|"⅛"|"⅜"|"⅝"|"⅞"
+GREEKS "α"|"β"|"γ"|"δ"|"ε"|"ζ"|"η"|"θ"|"ι"|"κ"|"λ"|"μ"|"ν"|"ξ"|"ο"|"π"|"ρ"|"ς"|"σ"|"τ"|"υ"|"φ"|"χ"|"ψ"|"ω"
+DEGREES "°"
+MINUTES "'"
+SECONDS "\""
+LETTERS [a-zA-Z]|{GREEKS}
+
+SUP_NUM {SUPER_DIGITS}+
+NSUP_NUM {SUPER_MINUS}{SUPER_DIGITS}+
+SUB_NUM {SUB_DIGITS}+
+WORD {LETTERS}+
+DEC_NUM {DEC}+|{DEC}*{DECIMAL}{DEC}+
+DEF_NUM {HEX}+|{HEX}*{DECIMAL}{HEX}+
+BASE_NUM {HEX}+{SUB_NUM}|{HEX}*{DECIMAL}{HEX}+{SUB_NUM}
+ANGLE_NUM {DEC_NUM}{DEGREES}|{DEC}+{DEGREES}{DEC_NUM}{MINUTES}|{DEC}+{DEGREES}{DEC}+{MINUTES}{DEC_NUM}{SECONDS}
+
+NUMBER {DEF_NUM}|{BASE_NUM}|{FRACTION}|{DEC}+{FRACTION}|{ANGLE_NUM}
+VARIABLE {WORD}|{WORD}{SUB_NUM}|{GREEKS}
+
+MOD [mM][oO][dD]
+AND "∧"|[aA][nN][dD]
+OR "∨"|[oO][rR]
+XOR "⊻"|"⊕"|[xX][oO][rR]
+NOT "¬"|"~"|[nN][oO][tT]
+RE "⃰ℜ"
+IM "ℑ"
+IN [iI][nN]
+
+%%
+
+"+" {return tADD;}
+"-"|"−" {return tSUBTRACT;}
+"*"|"×" {return tMULTIPLY;}
+"/"|"∕"|"÷" {return tDIVIDE;}
+{MOD} {return tMOD;}
+"⌊" {return tLFLOOR;}
+"⌋" {return tRFLOOR;}
+"⌈" {return tLCEILING;}
+"⌉" {return tRCEILING;}
+"√" {return tROOT;}
+"∛" {return tROOT3;}
+"∜" {return tROOT4;}
+{NOT} {return tNOT;}
+{AND} {return tAND;}
+{OR} {return tOR;}
+{XOR} {return tXOR;}
+{IN} {return tIN;}
+{NUMBER} {if (mp_set_from_string(yytext, _mp_equation_get_extra(yyscanner)->options->base, &yylval->int_t) != 0) REJECT; return tNUMBER;}
+{SUP_NUM} {yylval->integer = super_atoi(yytext); return tSUPNUM;}
+{NSUP_NUM} {yylval->integer = super_atoi(yytext); return tNSUPNUM;}
+{SUB_NUM} {yylval->integer = sub_atoi(yytext); return tSUBNUM;}
+{VARIABLE} {\
+ MPEquationParserState *state = _mp_equation_get_extra(yyscanner);\
+ if (state->function_is_defined(state, yytext)) {\
+ yylval->name = strdup(yytext);\
+ return tFUNCTION;\
+ }\
+ else {\
+ yylval->name = strdup(yytext);\
+ return tVARIABLE;\
+ }\
+}
+[ \r\t\n]
+. {return *yytext;}
+
+%%
diff --git a/src/mp-equation-parser.y b/src/mp-equation-parser.y
new file mode 100644
index 0000000..064f90f
--- /dev/null
+++ b/src/mp-equation-parser.y
@@ -0,0 +1,266 @@
+%{
+/* Copyright (c) 2004-2008 Sami Pietila
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <errno.h>
+#include <assert.h>
+
+#include "mp-equation-private.h"
+#include "mp-equation-parser.h"
+#include "mp-equation-lexer.h"
+
+// fixme support x log x
+// treat exp NAME exp as a function always and pass both arguments, i.e.
+// can do mod using both and all others use $1 * NAME($3)
+
+static void set_error(yyscan_t yyscanner, int error, const char *token)
+{
+ _mp_equation_get_extra(yyscanner)->error = error;
+ if (token)
+ _mp_equation_get_extra(yyscanner)->error_token = strdup(token);
+}
+
+static void set_result(yyscan_t yyscanner, const MPNumber *x)
+{
+ mp_set_from_mp(x, &(_mp_equation_get_extra(yyscanner))->ret);
+}
+
+static char *
+utf8_next_char (const char *c)
+{
+ c++;
+ while ((*c & 0xC0) == 0x80)
+ c++;
+ return (char *)c;
+}
+
+static int get_variable(yyscan_t yyscanner, const char *name, int power, MPNumber *z)
+{
+ int result = 0;
+
+ /* If defined, then get the variable */
+ if (_mp_equation_get_extra(yyscanner)->get_variable(_mp_equation_get_extra(yyscanner), name, z)) {
+ mp_xpowy_integer(z, power, z);
+ return 1;
+ }
+ 
+ /* If has more than one character then assume a multiplication of variables */
+ if (utf8_next_char(name)[0] != '\0') {
+ const char *c, *next;
+ char *buffer = malloc(sizeof(char) * strlen(name));
+ MPNumber value;
+
+ result = 1;
+ mp_set_from_integer(1, &value);
+ for (c = name; *c != '\0'; c = next) {
+ MPNumber t;
+
+ next = utf8_next_char(c);
+ snprintf(buffer, next - c + 1, "%s", c);
+
+ if (!_mp_equation_get_extra(yyscanner)->get_variable(_mp_equation_get_extra(yyscanner), buffer, &t)) {
+ result = 0;
+ break;
+ }
+
+ /* If last term do power */
+ if (*next == '\0')
+ mp_xpowy_integer(&t, power, &t);
+
+ mp_multiply(&value, &t, &value);
+ }
+
+ free(buffer);
+ if (result)
+ mp_set_from_mp(&value, z);
+ }
+
+ if (!result)
+ set_error(yyscanner, PARSER_ERR_UNKNOWN_VARIABLE, name);
+
+ return result;
+}
+
+static void set_variable(yyscan_t yyscanner, const char *name, MPNumber *x)
+{
+ _mp_equation_get_extra(yyscanner)->set_variable(_mp_equation_get_extra(yyscanner), name, x);
+}
+
+static int get_function(yyscan_t yyscanner, const char *name, const MPNumber *x, MPNumber *z)
+{
+ if (!_mp_equation_get_extra(yyscanner)->get_function(_mp_equation_get_extra(yyscanner), name, x, z)) {
+ set_error(yyscanner, PARSER_ERR_UNKNOWN_FUNCTION, name);
+ return 0;
+ }
+ return 1;
+}
+
+static int get_inverse_function(yyscan_t yyscanner, const char *name, const MPNumber *x, MPNumber *z)
+{
+ char *inv_name;
+ int result;
+ 
+ inv_name = malloc(sizeof(char) * (strlen(name) + strlen("⁻¹") + 1));
+ strcpy(inv_name, name);
+ strcat(inv_name, "⁻¹");
+ result = get_function(yyscanner, inv_name, x, z);
+ free(inv_name);
+
+ return result;
+}
+
+static void do_not(yyscan_t yyscanner, const MPNumber *x, MPNumber *z)
+{
+ if (!mp_is_overflow(x, _mp_equation_get_extra(yyscanner)->options->wordlen)) {
+ set_error(yyscanner, PARSER_ERR_OVERFLOW, NULL);
+ }
+ mp_not(x, _mp_equation_get_extra(yyscanner)->options->wordlen, z);
+}
+
+static char *make_unit(const char *name, int power)
+{
+ char *name2;
+
+ // FIXME: Hacky
+ if (power == 2) {
+ name2 = malloc(sizeof(char) * (strlen(name) + strlen("²") + 1));
+ sprintf(name2, "%s²", name);
+ }
+ else if (power == 3) {
+ name2 = malloc(sizeof(char) * (strlen(name) + strlen("³") + 1));
+ sprintf(name2, "%s³", name);
+ }
+ else {
+ name2 = malloc(sizeof(char) * (strlen(name) + strlen("?") + 1));
+ sprintf(name2, "%s?", name);
+ }
+ 
+ return name2;
+}
+
+static void do_conversion(yyscan_t yyscanner, const MPNumber *x, const char *x_units, const char *z_units, MPNumber *z)
+{
+ if (!_mp_equation_get_extra(yyscanner)->convert(_mp_equation_get_extra(yyscanner), x, x_units, z_units, z))
+ set_error(yyscanner, PARSER_ERR_UNKNOWN_CONVERSION, NULL);
+}
+
+%}
+
+%pure-parser
+%name-prefix="_mp_equation_"
+%locations
+%parse-param {yyscan_t yyscanner}
+%lex-param {yyscan_t yyscanner}
+
+%union {
+ MPNumber int_t;
+ int integer;
+ char *name;
+}
+
+%left <int_t> tNUMBER
+%left tLFLOOR tRFLOOR tLCEILING tRCEILING
+%left UNARY_PLUS
+%left tADD tSUBTRACT
+%left tAND tOR tXOR tXNOR
+%left tMULTIPLY tDIVIDE tMOD MULTIPLICATION
+%left tNOT
+%left tROOT tROOT3 tROOT4
+%left <name> tVARIABLE tFUNCTION
+%right <integer> tSUBNUM tSUPNUM tNSUPNUM
+%left BOOLEAN_OPERATOR
+%left PERCENTAGE
+%left UNARY_MINUS
+%right '^' '!' '|'
+%left tIN
+
+%type <int_t> exp variable term
+%type <name> unit
+%start statement
+
+%%
+
+statement:
+ exp { set_result(yyscanner, &$1); }
+| exp '=' { set_result(yyscanner, &$1); }
+| tVARIABLE '=' exp {set_variable(yyscanner, $1, &$3); set_result(yyscanner, &$3); }
+| tNUMBER unit tIN unit { MPNumber t; do_conversion(yyscanner, &$1, $2, $4, &t); set_result(yyscanner, &t); free($2); free($4); }
+| unit tIN unit { MPNumber x, t; mp_set_from_integer(1, &x); do_conversion(yyscanner, &x, $1, $3, &t); set_result(yyscanner, &t); free($1); free($3); }
+;
+
+unit:
+ tVARIABLE {$$ = $1;}
+| tVARIABLE tSUPNUM {$$ = make_unit($1, $2); free($1);}
+
+/* |x| gets confused and thinks = |x|(...||) */
+
+exp:
+ '(' exp ')' {mp_set_from_mp(&$2, &$$);}
+| exp '(' exp ')' {mp_multiply(&$1, &$3, &$$);}
+| tLFLOOR exp tRFLOOR {mp_floor(&$2, &$$);}
+| tLCEILING exp tRCEILING {mp_ceiling(&$2, &$$);}
+| '[' exp ']' {mp_round(&$2, &$$);}
+| '{' exp '}' {mp_fractional_part(&$2, &$$);}
+| '|' exp '|' {mp_abs(&$2, &$$);}
+| exp '^' exp {mp_xpowy(&$1, &$3, &$$);}
+| exp tSUPNUM {mp_xpowy_integer(&$1, $2, &$$);}
+| exp tNSUPNUM {mp_xpowy_integer(&$1, $2, &$$);}
+| exp '!' {mp_factorial(&$1, &$$);}
+| variable {mp_set_from_mp(&$1, &$$);}
+| tNUMBER variable %prec MULTIPLICATION {mp_multiply(&$1, &$2, &$$);}
+| tSUBTRACT exp %prec UNARY_MINUS {mp_invert_sign(&$2, &$$);}
+| tADD tNUMBER %prec UNARY_PLUS {mp_set_from_mp(&$2, &$$);}
+| exp tDIVIDE exp {mp_divide(&$1, &$3, &$$);}
+| exp tMOD exp {mp_modulus_divide(&$1, &$3, &$$);}
+| exp tMULTIPLY exp {mp_multiply(&$1, &$3, &$$);}
+| exp tADD exp '%' %prec PERCENTAGE {mp_add_integer(&$3, 100, &$3); mp_divide_integer(&$3, 100, &$3); mp_multiply(&$1, &$3, &$$);}
+| exp tSUBTRACT exp '%' %prec PERCENTAGE {mp_add_integer(&$3, -100, &$3); mp_divide_integer(&$3, -100, &$3); mp_multiply(&$1, &$3, &$$);}
+| exp tADD exp {mp_add(&$1, &$3, &$$);}
+| exp tSUBTRACT exp {mp_subtract(&$1, &$3, &$$);}
+| exp '%' {mp_divide_integer(&$1, 100, &$$);}
+| tNOT exp {do_not(yyscanner, &$2, &$$);}
+| exp tAND exp %prec BOOLEAN_OPERATOR {mp_and(&$1, &$3, &$$);}
+| exp tOR exp %prec BOOLEAN_OPERATOR {mp_or(&$1, &$3, &$$);}
+| exp tXOR exp %prec BOOLEAN_OPERATOR {mp_xor(&$1, &$3, &$$);}
+| tNUMBER {mp_set_from_mp(&$1, &$$);}
+;
+
+
+variable:
+ term {mp_set_from_mp(&$1, &$$);}
+| tFUNCTION exp {if (!get_function(yyscanner, $1, &$2, &$$)) YYABORT; free($1);}
+| tFUNCTION tSUPNUM exp {if (!get_function(yyscanner, $1, &$3, &$$)) YYABORT; mp_xpowy_integer(&$$, $2, &$$); free($1);}
+| tFUNCTION tNSUPNUM exp {if (!get_inverse_function(yyscanner, $1, &$3, &$$)) YYABORT; mp_xpowy_integer(&$$, -$2, &$$); free($1);}
+| tVARIABLE tSUPNUM exp {set_error(yyscanner, PARSER_ERR_UNKNOWN_FUNCTION, $1); free($1); YYABORT;}
+| tSUBNUM tROOT exp {mp_root(&$3, $1, &$$);}
+| tROOT exp {mp_sqrt(&$2, &$$);}
+| tROOT3 exp {mp_root(&$2, 3, &$$);}
+| tROOT4 exp {mp_root(&$2, 4, &$$);}
+;
+
+term:
+ tVARIABLE {if (!get_variable(yyscanner, $1, 1, &$$)) YYABORT; free($1);}
+| tVARIABLE tSUPNUM {if (!get_variable(yyscanner, $1, $2, &$$)) YYABORT; free($1);}
+| term term {mp_multiply(&$1, &$2, &$$);}
+;
+
+%%
diff --git a/src/mp-equation-private.h b/src/mp-equation-private.h
new file mode 100644
index 0000000..7ef96c2
--- /dev/null
+++ b/src/mp-equation-private.h
@@ -0,0 +1,64 @@
+/* Copyright (c) 2004-2008 Sami Pietila
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef MP_EQUATION_PRIVATE_H
+#define MP_EQUATION_PRIVATE_H
+
+#include "mp-equation.h"
+
+typedef struct MPEquationParserState MPEquationParserState;
+
+/* State for parser */
+struct MPEquationParserState {
+ /* User provided options */
+ MPEquationOptions *options;
+
+ /* Function to check if a variable is defined */
+ int (*variable_is_defined)(MPEquationParserState *state, const char *name);
+
+ /* Function to get variable values */
+ int (*get_variable)(MPEquationParserState *state, const char *name, MPNumber *z);
+
+ /* Function to set variable values */
+ void (*set_variable)(MPEquationParserState *state, const char *name, const MPNumber *x);
+
+ /* Function to check if a function is defined */
+ int (*function_is_defined)(MPEquationParserState *state, const char *name);
+
+ /* Function to solve functions */
+ int (*get_function)(MPEquationParserState *state, const char *name, const MPNumber *x, MPNumber *z);
+
+ /* Function to convert units */
+ int (*convert)(MPEquationParserState *state, const MPNumber *x, const char *x_units, const char *z_units, MPNumber *z);
+
+ // FIXME: get_operator??
+
+ /* Error returned from parser */
+ int error;
+
+ /* Name of token where error occured */
+ char *error_token;
+
+ /* Value returned from parser */
+ MPNumber ret;
+};
+
+int _mp_equation_error(void *yylloc, MPEquationParserState *state, char *text);
+
+#endif
diff --git a/src/mp-equation.c b/src/mp-equation.c
new file mode 100644
index 0000000..34f698b
--- /dev/null
+++ b/src/mp-equation.c
@@ -0,0 +1,493 @@
+/* Copyright (c) 2004-2008 Sami Pietila
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <ctype.h>
+
+#include "mp-equation-private.h"
+#include "mp-equation-parser.h"
+#include "mp-equation-lexer.h"
+
+extern int _mp_equation_parse(yyscan_t yyscanner);
+
+
+static int
+variable_is_defined(MPEquationParserState *state, const char *name)
+{
+ /* FIXME: Make more generic */
+ if (strcmp(name, "e") == 0 || strcmp(name, "i") == 0 || strcmp(name, "π") == 0)
+ return 1;
+ if (state->options->variable_is_defined)
+ return state->options->variable_is_defined(name, state->options->callback_data);
+ return 0;
+}
+
+
+static int
+get_variable(MPEquationParserState *state, const char *name, MPNumber *z)
+{
+ int result = 1;
+
+ if (strcmp(name, "e") == 0)
+ mp_get_eulers(z);
+ else if (strcmp(name, "i") == 0)
+ mp_get_i(z);
+ else if (strcmp(name, "π") == 0)
+ mp_get_pi(z);
+ else if (state->options->get_variable)
+ result = state->options->get_variable(name, z, state->options->callback_data);
+ else
+ result = 0;
+
+ return result;
+}
+
+static void
+set_variable(MPEquationParserState *state, const char *name, const MPNumber *x)
+{
+ // Reserved words, e, π, mod, and, or, xor, not, abs, log, ln, sqrt, int, frac, sin, cos, ...
+ if (strcmp(name, "e") == 0 || strcmp(name, "i") == 0 || strcmp(name, "π") == 0)
+ return; // FALSE
+
+ if (state->options->set_variable)
+ state->options->set_variable(name, x, state->options->callback_data);
+}
+
+// FIXME: Accept "2sin" not "2 sin", i.e. let the tokenizer collect the multiple
+// Parser then distinguishes between "sin"="s*i*n" or "sin5" = "sin 5" = "sin(5)"
+// i.e. numbers+letters = variable or function depending on following arg
+// letters+numbers = numbers+letters+numbers = function
+
+
+int
+sub_atoi(const char *data)
+{
+ int i, value = 0;
+ const char *digits[] = {"₀", "₁", "₂", "₃", "₄", "₅", "₆", "₇", "₈", "₉", NULL};
+
+ do {
+ for(i = 0; digits[i] != NULL && strncmp(data, digits[i], strlen(digits[i])) != 0; i++);
+ if(digits[i] == NULL)
+ return -1;
+ data += strlen(digits[i]);
+ value = value * 10 + i;
+ } while(*data != '\0');
+
+ return value;
+}
+
+int
+super_atoi(const char *data)
+{
+ int i, sign = 1, value = 0;
+ const char *digits[11] = {"⁰", "¹", "²", "³", "⁴", "⁵", "⁶", "⁷", "⁸", "⁹", NULL};
+
+ if(strncmp(data, "⁻", strlen("⁻")) == 0) {
+ sign = -1;
+ data += strlen("⁻");
+ }
+
+ do {
+ for(i = 0; digits[i] != NULL && strncmp(data, digits[i], strlen(digits[i])) != 0; i++);
+ if(digits[i] == NULL)
+ return 0;
+ value = value * 10 + i;
+ data += strlen(digits[i]);
+ } while(*data != '\0');
+
+ return sign * value;
+}
+
+
+static int
+function_is_defined(MPEquationParserState *state, const char *name)
+{
+ char *c, *lower_name;
+
+ lower_name = strdup(name);
+ for (c = lower_name; *c; c++)
+ *c = tolower(*c);
+
+ /* FIXME: Make more generic */
+ if (strcmp(lower_name, "log") == 0 ||
+ (strncmp(lower_name, "log", 3) == 0 && sub_atoi(lower_name + 3) >= 0) ||
+ strcmp(lower_name, "ln") == 0 ||
+ strcmp(lower_name, "sqrt") == 0 ||
+ strcmp(lower_name, "abs") == 0 ||
+ strcmp(lower_name, "sgn") == 0 ||
+ strcmp(lower_name, "arg") == 0 ||
+ strcmp(lower_name, "conj") == 0 ||
+ strcmp(lower_name, "int") == 0 ||
+ strcmp(lower_name, "frac") == 0 ||
+ strcmp(lower_name, "floor") == 0 ||
+ strcmp(lower_name, "ceil") == 0 ||
+ strcmp(lower_name, "round") == 0 ||
+ strcmp(lower_name, "re") == 0 ||
+ strcmp(lower_name, "im") == 0 ||
+ strcmp(lower_name, "sin") == 0 || strcmp(lower_name, "cos") == 0 || strcmp(lower_name, "tan") == 0 ||
+ strcmp(lower_name, "sin⁻¹") == 0 || strcmp(lower_name, "cos⁻¹") == 0 || strcmp(lower_name, "tan⁻¹") == 0 ||
+ strcmp(lower_name, "sinh") == 0 || strcmp(lower_name, "cosh") == 0 || strcmp(lower_name, "tanh") == 0 ||
+ strcmp(lower_name, "sinh⁻¹") == 0 || strcmp(lower_name, "cosh⁻¹") == 0 || strcmp(lower_name, "tanh⁻¹") == 0 ||
+ strcmp(lower_name, "asinh") == 0 || strcmp(lower_name, "acosh") == 0 || strcmp(lower_name, "atanh") == 0 ||
+ strcmp(lower_name, "ones") == 0 ||
+ strcmp(lower_name, "twos") == 0) {
+ g_free (lower_name);
+ return 1;
+ }
+ g_free (lower_name);
+
+ if (state->options->function_is_defined)
+ return state->options->function_is_defined(name, state->options->callback_data);
+ return 0;
+}
+
+
+static int
+get_function(MPEquationParserState *state, const char *name, const MPNumber *x, MPNumber *z)
+{
+ char *c, *lower_name;
+ int result = 1;
+
+ lower_name = strdup(name);
+ for (c = lower_name; *c; c++)
+ *c = tolower(*c);
+
+ // FIXME: Re Im ?
+
+ if (strcmp(lower_name, "log") == 0)
+ mp_logarithm(10, x, z); // FIXME: Default to ln
+ else if (strncmp(lower_name, "log", 3) == 0) {
+ int base;
+
+ base = sub_atoi(lower_name + 3);
+ if (base < 0)
+ result = 0;
+ else
+ mp_logarithm(base, x, z);
+ }
+ else if (strcmp(lower_name, "ln") == 0)
+ mp_ln(x, z);
+ else if (strcmp(lower_name, "sqrt") == 0) // √x
+ mp_sqrt(x, z);
+ else if (strcmp(lower_name, "abs") == 0) // |x|
+ mp_abs(x, z);
+ else if (strcmp(lower_name, "sgn") == 0)
+ mp_sgn(x, z);
+ else if (strcmp(lower_name, "arg") == 0)
+ mp_arg(x, state->options->angle_units, z);
+ else if (strcmp(lower_name, "conj") == 0)
+ mp_conjugate(x, z);
+ else if (strcmp(lower_name, "int") == 0)
+ mp_integer_component(x, z);
+ else if (strcmp(lower_name, "frac") == 0)
+ mp_fractional_component(x, z);
+ else if (strcmp(lower_name, "floor") == 0)
+ mp_floor(x, z);
+ else if (strcmp(lower_name, "ceil") == 0)
+ mp_ceiling(x, z);
+ else if (strcmp(lower_name, "round") == 0)
+ mp_round(x, z);
+ else if (strcmp(lower_name, "re") == 0)
+ mp_real_component(x, z);
+ else if (strcmp(lower_name, "im") == 0)
+ mp_imaginary_component(x, z);
+ else if (strcmp(lower_name, "sin") == 0)
+ mp_sin(x, state->options->angle_units, z);
+ else if (strcmp(lower_name, "cos") == 0)
+ mp_cos(x, state->options->angle_units, z);
+ else if (strcmp(lower_name, "tan") == 0)
+ mp_tan(x, state->options->angle_units, z);
+ else if (strcmp(lower_name, "sin⁻¹") == 0 || strcmp(lower_name, "asin") == 0)
+ mp_asin(x, state->options->angle_units, z);
+ else if (strcmp(lower_name, "cos⁻¹") == 0 || strcmp(lower_name, "acos") == 0)
+ mp_acos(x, state->options->angle_units, z);
+ else if (strcmp(lower_name, "tan⁻¹") == 0 || strcmp(lower_name, "atan") == 0)
+ mp_atan(x, state->options->angle_units, z);
+ else if (strcmp(lower_name, "sinh") == 0)
+ mp_sinh(x, z);
+ else if (strcmp(lower_name, "cosh") == 0)
+ mp_cosh(x, z);
+ else if (strcmp(lower_name, "tanh") == 0)
+ mp_tanh(x, z);
+ else if (strcmp(lower_name, "sinh⁻¹") == 0 || strcmp(lower_name, "asinh") == 0)
+ mp_asinh(x, z);
+ else if (strcmp(lower_name, "cosh⁻¹") == 0 || strcmp(lower_name, "acosh") == 0)
+ mp_acosh(x, z);
+ else if (strcmp(lower_name, "tanh⁻¹") == 0 || strcmp(lower_name, "atanh") == 0)
+ mp_atanh(x, z);
+ else if (strcmp(lower_name, "ones") == 0)
+ mp_ones_complement(x, state->options->wordlen, z);
+ else if (strcmp(lower_name, "twos") == 0)
+ mp_twos_complement(x, state->options->wordlen, z);
+ else if (state->options->get_function)
+ result = state->options->get_function(name, x, z, state->options->callback_data);
+ else
+ result = 0;
+
+ free(lower_name);
+
+ return result;
+}
+
+
+static int
+do_convert(const char *units[][2], const MPNumber *x, const char *x_units, const char *z_units, MPNumber *z)
+{
+ int x_index, z_index;
+ MPNumber x_factor, z_factor;
+ 
+ for (x_index = 0; units[x_index][0] != NULL && strcmp(units[x_index][0], x_units) != 0; x_index++);
+ if (units[x_index][0] == NULL)
+ return 0;
+ for (z_index = 0; units[z_index][0] != NULL && strcmp(units[z_index][0], z_units) != 0; z_index++);
+ if (units[z_index][0] == NULL)
+ return 0;
+
+ mp_set_from_string(units[x_index][1], 10, &x_factor);
+ mp_set_from_string(units[z_index][1], 10, &z_factor);
+ mp_multiply(x, &x_factor, z);
+ mp_divide(z, &z_factor, z);
+
+ return 1;
+}
+
+
+static int
+convert(MPEquationParserState *state, const MPNumber *x, const char *x_units, const char *z_units, MPNumber *z)
+{
+ const char *length_units[][2] = {
+ {"parsec", "30857000000000000"},
+ {"parsecs", "30857000000000000"},
+ {"pc", "30857000000000000"},
+ {"lightyear", "9460730472580800"},
+ {"lightyears", "9460730472580800"},
+ {"ly", "9460730472580800"},
+ {"au", "149597870691"},
+ {"nm", "1852000"},
+ {"mile", "1609.344"},
+ {"miles", "1609.344"},
+ {"mi", "1609.344"},
+ {"kilometer", "1000"},
+ {"kilometers", "1000"},
+ {"km", "1000"},
+ {"kms", "1000"},
+ {"cable", "219.456"},
+ {"cables", "219.456"},
+ {"cb", "219.456"},
+ {"fathom", "1.8288"},
+ {"fathoms", "1.8288"},
+ {"ftm", "1.8288"},
+ {"meter", "1"},
+ {"meters", "1"},
+ {"m", "1"},
+ {"yard", "0.9144"},
+ {"yd", "0.9144"},
+ {"foot", "0.3048"},
+ {"feet", "0.3048"},
+ {"ft", "0.3048"},
+ {"inch", "0.0254"},
+ {"inches", "0.0254"},
+ {"centimeter", "0.01"},
+ {"centimeters", "0.01"},
+ {"cm", "0.01"},
+ {"cms", "0.01"},
+ {"millimeter", "0.001"},
+ {"millimeters", "0.001"},
+ {"mm", "0.001"},
+ {"micrometer", "0.000001"},
+ {"micrometers", "0.000001"},
+ {"um", "0.000001"},
+ {"nanometer", "0.000000001"},
+ {"nanometers", "0.000000001"},
+ {NULL, NULL}
+ };
+
+ const char *area_units[][2] = {
+ {"hectare", "10000"},
+ {"hectares", "10000"},
+ {"acre", "4046.8564224"},
+ {"acres", "4046.8564224"},
+ {"m²", "1"},
+ {"cm²", "0.001"},
+ {"mm²", "0.000001"},
+ {NULL, NULL}
+ };
+
+ const char *volume_units[][2] = {
+ {"m³", "1000"},
+ {"gallon", "3.785412"},
+ {"gallons", "3.785412"},
+ {"gal", "3.785412"},
+ {"litre", "1"},
+ {"litres", "1"},
+ {"liter", "1"},
+ {"liters", "1"},
+ {"L", "1"},
+ {"quart", "0.9463529"},
+ {"quarts", "0.9463529"},
+ {"qt", "0.9463529"},
+ {"pint", "0.4731765"},
+ {"pints", "0.4731765"},
+ {"pt", "0.4731765"},
+ {"millilitre", "0.001"},
+ {"millilitres", "0.001"},
+ {"milliliter", "0.001"},
+ {"milliliters", "0.001"},
+ {"mL", "0.001"},
+ {"cm³", "0.001"},
+ {"mm³", "0.000001"},
+ {NULL, NULL}
+ };
+
+ const char *weight_units[][2] = {
+ {"tonne", "1000"},
+ {"tonnes", "1000"},
+ {"kilograms", "1"},
+ {"kilogramme", "1"},
+ {"kilogrammes", "1"},
+ {"kg", "1"},
+ {"kgs", "1"},
+ {"pound", "0.45359237"},
+ {"pounds", "0.45359237"},
+ {"lb", "0.45359237"},
+ {"ounce", "0.002834952"},
+ {"ounces", "0.002834952"},
+ {"oz", "0.002834952"},
+ {"gram", "0.001"},
+ {"grams", "0.001"},
+ {"gramme", "0.001"},
+ {"grammes", "0.001"},
+ {"g", "0.001"},
+ {NULL, NULL}
+ };
+ 
+ const char *time_units[][2] = {
+ {"year", "31557600"},
+ {"years", "31557600"},
+ {"day", "86400"},
+ {"days", "86400"},
+ {"hour", "3600"},
+ {"hours", "3600"},
+ {"minute", "60"},
+ {"minutes", "60"},
+ {"second", "1"},
+ {"seconds", "1"},
+ {"s", "1"},
+ {"millisecond", "0.001"},
+ {"milliseconds", "0.001"},
+ {"ms", "0.001"},
+ {"microsecond", "0.000001"},
+ {"microseconds", "0.000001"},
+ {"us", "0.000001"},
+ {NULL, NULL}
+ };
+
+ if (do_convert(length_units, x, x_units, z_units, z) ||
+ do_convert(area_units, x, x_units, z_units, z) ||
+ do_convert(volume_units, x, x_units, z_units, z) ||
+ do_convert(weight_units, x, x_units, z_units, z) ||
+ do_convert(time_units, x, x_units, z_units, z))
+ return 1;
+
+ if (state->options->convert)
+ return state->options->convert(x, x_units, z_units, z, state->options->callback_data);
+ 
+ return 0;
+}
+
+
+MPErrorCode
+mp_equation_parse(const char *expression, MPEquationOptions *options, MPNumber *result, char **error_token)
+{
+ int ret;
+ MPEquationParserState state;
+ yyscan_t yyscanner;
+ YY_BUFFER_STATE buffer;
+
+ if (!(expression && result) || strlen(expression) == 0)
+ return PARSER_ERR_INVALID;
+
+ memset(&state, 0, sizeof(MPEquationParserState));
+ state.options = options;
+ state.variable_is_defined = variable_is_defined;
+ state.get_variable = get_variable;
+ state.set_variable = set_variable;
+ state.function_is_defined = function_is_defined;
+ state.get_function = get_function;
+ state.convert = convert;
+ state.error = 0;
+
+ mp_clear_error();
+
+ _mp_equation_lex_init_extra(&state, &yyscanner);
+ buffer = _mp_equation__scan_string(expression, yyscanner);
+
+ ret = _mp_equation_parse(yyscanner);
+ if (state.error_token != NULL && error_token != NULL) {
+ *error_token = state.error_token;
+ }
+
+ _mp_equation__delete_buffer(buffer, yyscanner);
+ _mp_equation_lex_destroy(yyscanner);
+
+ /* Error during parsing */
+ if (state.error)
+ return state.error;
+
+ if (mp_get_error())
+ return PARSER_ERR_MP;
+
+ /* Failed to parse */
+ if (ret)
+ return PARSER_ERR_INVALID;
+
+ mp_set_from_mp(&state.ret, result);
+
+ return PARSER_ERR_NONE;
+}
+
+
+const char *
+mp_error_code_to_string(MPErrorCode error_code)
+{
+ switch(error_code)
+ {
+ case PARSER_ERR_NONE:
+ return "PARSER_ERR_NONE";
+ case PARSER_ERR_INVALID:
+ return "PARSER_ERR_INVALID";
+ case PARSER_ERR_OVERFLOW:
+ return "PARSER_ERR_OVERFLOW";
+ case PARSER_ERR_UNKNOWN_VARIABLE:
+ return "PARSER_ERR_UNKNOWN_VARIABLE";
+ case PARSER_ERR_UNKNOWN_FUNCTION:
+ return "PARSER_ERR_UNKNOWN_FUNCTION";
+ case PARSER_ERR_UNKNOWN_CONVERSION:
+ return "PARSER_ERR_UNKNOWN_CONVERSION";
+ case PARSER_ERR_MP:
+ return "PARSER_ERR_MP";
+ default:
+ return "Unknown parser error";
+ }
+}
+
+
+int _mp_equation_error(void *yylloc, MPEquationParserState *state, char *text)
+{
+ return 0;
+}
diff --git a/src/mp-equation.h b/src/mp-equation.h
new file mode 100644
index 0000000..60e6690
--- /dev/null
+++ b/src/mp-equation.h
@@ -0,0 +1,77 @@
+/* Copyright (c) 2004-2008 Sami Pietila
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef MP_EQUATION_H
+#define MP_EQUATION_H
+
+#include "mp.h"
+
+typedef enum
+{
+ PARSER_ERR_NONE = 0,
+ PARSER_ERR_INVALID,
+ PARSER_ERR_OVERFLOW,
+ PARSER_ERR_UNKNOWN_VARIABLE,
+ PARSER_ERR_UNKNOWN_FUNCTION,
+ PARSER_ERR_UNKNOWN_CONVERSION,
+ PARSER_ERR_MP
+} MPErrorCode;
+
+/* Options for parser */
+typedef struct {
+ /* Default number base */
+ int base;
+
+ /* The wordlength for binary operations in bits (e.g. 8, 16, 32) */
+ int wordlen;
+
+ /* Units for angles (e.g. radians, degrees) */
+ MPAngleUnit angle_units;
+
+ // FIXME:
+ // int enable_builtins;
+
+ /* Data to pass to callbacks */
+ void *callback_data;
+ 
+ /* Function to check if a variable is defined */
+ int (*variable_is_defined)(const char *name, void *data);
+
+ /* Function to get variable values */
+ int (*get_variable)(const char *name, MPNumber *z, void *data);
+
+ /* Function to set variable values */
+ void (*set_variable)(const char *name, const MPNumber *x, void *data);
+
+ /* Function to check if a function is defined */
+ int (*function_is_defined)(const char *name, void *data);
+
+ /* Function to solve functions */
+ int (*get_function)(const char *name, const MPNumber *x, MPNumber *z, void *data);
+
+ /* Function to convert units */
+ int (*convert)(const MPNumber *x, const char *x_units, const char *z_units, MPNumber *z, void *data);
+} MPEquationOptions;
+
+MPErrorCode mp_equation_parse(const char *expression, MPEquationOptions *options, MPNumber *result, char **error_token);
+const char *mp_error_code_to_string(MPErrorCode error_code);
+
+int sub_atoi(const char *data);
+int super_atoi(const char *data);
+#endif
diff --git a/src/mp-private.h b/src/mp-private.h
new file mode 100644
index 0000000..94b1530
--- /dev/null
+++ b/src/mp-private.h
@@ -0,0 +1,47 @@
+/* Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef MP_INTERNAL_H
+#define MP_INTERNAL_H
+
+#include <glib/gi18n.h>
+
+/* If we're not using GNU C, elide __attribute__ */
+#ifndef __GNUC__
+# define __attribute__(x) /*NOTHING*/
+#endif
+
+#define min(a, b) ((a) <= (b) ? (a) : (b))
+#define max(a, b) ((a) >= (b) ? (a) : (b))
+
+//2E0 BELOW ENSURES AT LEAST ONE GUARD DIGIT
+//MP.t = (int) ((float) (accuracy) * log((float)10.) / log((float) MP_BASE) + (float) 2.0);
+//if (MP.t > MP_SIZE) {
+// mperr("MP_SIZE TOO SMALL IN CALL TO MPSET, INCREASE MP_SIZE AND DIMENSIONS OF MP ARRAYS TO AT LEAST %d ***", MP.t);
+// MP.t = MP_SIZE;
+//}
+#define MP_T 100
+
+void mperr(const char *format, ...) __attribute__((format(printf, 1, 2)));
+void mp_gcd(int64_t *, int64_t *);
+void mp_normalize(MPNumber *);
+void convert_to_radians(const MPNumber *x, MPAngleUnit unit, MPNumber *z);
+void convert_from_radians(const MPNumber *x, MPAngleUnit unit, MPNumber *z);
+
+#endif /* MP_INTERNAL_H */
diff --git a/src/mp-trigonometric.c b/src/mp-trigonometric.c
new file mode 100644
index 0000000..2ebc676
--- /dev/null
+++ b/src/mp-trigonometric.c
@@ -0,0 +1,628 @@
+/* Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <libintl.h>
+
+#include "mp.h"
+#include "mp-private.h"
+
+static int
+mp_compare_mp_to_int(const MPNumber *x, int i)
+{
+ MPNumber t;
+ mp_set_from_integer(i, &t);
+ return mp_compare_mp_to_mp(x, &t);
+}
+
+
+/* Convert x to radians */
+void
+convert_to_radians(const MPNumber *x, MPAngleUnit unit, MPNumber *z)
+{
+ MPNumber t1, t2;
+
+ switch(unit) {
+ default:
+ case MP_RADIANS:
+ mp_set_from_mp(x, z);
+ break;
+
+ case MP_DEGREES:
+ mp_get_pi(&t1);
+ mp_multiply(x, &t1, &t2);
+ mp_divide_integer(&t2, 180, z);
+ break;
+
+ case MP_GRADIANS:
+ mp_get_pi(&t1);
+ mp_multiply(x, &t1, &t2);
+ mp_divide_integer(&t2, 200, z);
+ break;
+ }
+}
+
+
+void
+mp_get_pi(MPNumber *z)
+{
+ mp_set_from_string("3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679", 10, z);
+}
+
+
+void
+convert_from_radians(const MPNumber *x, MPAngleUnit unit, MPNumber *z)
+{
+ MPNumber t1, t2;
+
+ switch (unit) {
+ default:
+ case MP_RADIANS:
+ mp_set_from_mp(x, z);
+ break;
+
+ case MP_DEGREES:
+ mp_multiply_integer(x, 180, &t2);
+ mp_get_pi(&t1);
+ mp_divide(&t2, &t1, z);
+ break;
+
+ case MP_GRADIANS:
+ mp_multiply_integer(x, 200, &t2);
+ mp_get_pi(&t1);
+ mp_divide(&t2, &t1, z);
+ break;
+ }
+}
+
+
+/* z = sin(x) -1 >= x >= 1, do_sin = 1
+ * z = cos(x) -1 >= x >= 1, do_sin = 0
+ */
+static void
+mpsin1(const MPNumber *x, MPNumber *z, int do_sin)
+{
+ int i, b2;
+ MPNumber t1, t2;
+
+ /* sin(0) = 0, cos(0) = 1 */
+ if (mp_is_zero(x)) {
+ if (do_sin == 0)
+ mp_set_from_integer(1, z);
+ else
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ mp_multiply(x, x, &t2);
+ if (mp_compare_mp_to_int(&t2, 1) > 0) {
+ mperr("*** ABS(X) > 1 IN CALL TO MPSIN1 ***");
+ }
+
+ if (do_sin == 0) {
+ mp_set_from_integer(1, &t1);
+ mp_set_from_integer(0, z);
+ i = 1;
+ } else {
+ mp_set_from_mp(x, &t1);
+ mp_set_from_mp(&t1, z);
+ i = 2;
+ }
+
+ /* Taylor series */
+ /* POWER SERIES LOOP. REDUCE T IF POSSIBLE */
+ b2 = 2 * max(MP_BASE, 64);
+ do {
+ if (MP_T + t1.exponent <= 0)
+ break;
+
+ /* IF I*(I+1) IS NOT REPRESENTABLE AS AN INTEGER, THE FOLLOWING
+ * DIVISION BY I*(I+1) HAS TO BE SPLIT UP.
+ */
+ mp_multiply(&t2, &t1, &t1);
+ if (i > b2) {
+ mp_divide_integer(&t1, -i, &t1);
+ mp_divide_integer(&t1, i + 1, &t1);
+ } else {
+ mp_divide_integer(&t1, -i * (i + 1), &t1);
+ }
+ mp_add(&t1, z, z);
+
+ i += 2;
+ } while (t1.sign != 0);
+
+ if (do_sin == 0)
+ mp_add_integer(z, 1, z);
+}
+
+
+static void
+mp_sin_real(const MPNumber *x, MPAngleUnit unit, MPNumber *z)
+{
+ int xs;
+ MPNumber x_radians;
+
+ /* sin(0) = 0 */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ convert_to_radians(x, unit, &x_radians);
+
+ xs = x_radians.sign;
+ mp_abs(&x_radians, &x_radians);
+
+ /* USE MPSIN1 IF ABS(X) <= 1 */
+ if (mp_compare_mp_to_int(&x_radians, 1) <= 0) {
+ mpsin1(&x_radians, z, 1);
+ }
+ /* FIND ABS(X) MODULO 2PI */
+ else {
+ mp_get_pi(z);
+ mp_divide_integer(z, 4, z);
+ mp_divide(&x_radians, z, &x_radians);
+ mp_divide_integer(&x_radians, 8, &x_radians);
+ mp_fractional_component(&x_radians, &x_radians);
+
+ /* SUBTRACT 1/2, SAVE SIGN AND TAKE ABS */
+ mp_add_fraction(&x_radians, -1, 2, &x_radians);
+ xs = -xs * x_radians.sign;
+ if (xs == 0) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ x_radians.sign = 1;
+ mp_multiply_integer(&x_radians, 4, &x_radians);
+
+ /* IF NOT LESS THAN 1, SUBTRACT FROM 2 */
+ if (x_radians.exponent > 0)
+ mp_add_integer(&x_radians, -2, &x_radians);
+
+ if (mp_is_zero(&x_radians)) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ x_radians.sign = 1;
+ mp_multiply_integer(&x_radians, 2, &x_radians);
+
+ /* NOW REDUCED TO FIRST QUADRANT, IF LESS THAN PI/4 USE
+ * POWER SERIES, ELSE COMPUTE COS OF COMPLEMENT
+ */
+ if (x_radians.exponent > 0) {
+ mp_add_integer(&x_radians, -2, &x_radians);
+ mp_multiply(&x_radians, z, &x_radians);
+ mpsin1(&x_radians, z, 0);
+ } else {
+ mp_multiply(&x_radians, z, &x_radians);
+ mpsin1(&x_radians, z, 1);
+ }
+ }
+
+ z->sign = xs;
+}
+
+
+static void
+mp_cos_real(const MPNumber *x, MPAngleUnit unit, MPNumber *z)
+{
+ /* cos(0) = 1 */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(1, z);
+ return;
+ }
+
+ convert_to_radians(x, unit, z);
+
+ /* Use power series if |x| <= 1 */
+ mp_abs(z, z);
+ if (mp_compare_mp_to_int(z, 1) <= 0) {
+ mpsin1(z, z, 0);
+ } else {
+ MPNumber t;
+
+ /* cos(x) = sin(π/2 - |x|) */
+ mp_get_pi(&t);
+ mp_divide_integer(&t, 2, &t);
+ mp_subtract(&t, z, z);
+ mp_sin(z, MP_RADIANS, z);
+ }
+}
+
+
+void
+mp_sin(const MPNumber *x, MPAngleUnit unit, MPNumber *z)
+{
+ if (mp_is_complex(x)) {
+ MPNumber x_real, x_im, z_real, z_im, t;
+
+ mp_real_component(x, &x_real);
+ mp_imaginary_component(x, &x_im);
+
+ mp_sin_real(&x_real, unit, &z_real);
+ mp_cosh(&x_im, &t);
+ mp_multiply(&z_real, &t, &z_real);
+
+ mp_cos_real(&x_real, unit, &z_im);
+ mp_sinh(&x_im, &t);
+ mp_multiply(&z_im, &t, &z_im);
+
+ mp_set_from_complex(&z_real, &z_im, z);
+ }
+ else
+ mp_sin_real(x, unit, z);
+}
+
+
+void
+mp_cos(const MPNumber *x, MPAngleUnit unit, MPNumber *z)
+{
+ if (mp_is_complex(x)) {
+ MPNumber x_real, x_im, z_real, z_im, t;
+
+ mp_real_component(x, &x_real);
+ mp_imaginary_component(x, &x_im);
+
+ mp_cos_real(&x_real, unit, &z_real);
+ mp_cosh(&x_im, &t);
+ mp_multiply(&z_real, &t, &z_real);
+
+ mp_sin_real(&x_real, unit, &z_im);
+ mp_sinh(&x_im, &t);
+ mp_multiply(&z_im, &t, &z_im);
+ mp_invert_sign(&z_im, &z_im);
+
+ mp_set_from_complex(&z_real, &z_im, z);
+ }
+ else
+ mp_cos_real(x, unit, z);
+}
+
+
+void
+mp_tan(const MPNumber *x, MPAngleUnit unit, MPNumber *z)
+{
+ MPNumber cos_x, sin_x;
+
+ /* Check for undefined values */
+ mp_cos(x, unit, &cos_x);
+ if (mp_is_zero(&cos_x)) {
+ /* Translators: Error displayed when tangent value is undefined */
+ mperr(_("Tangent is undefined for angles that are multiples of π (180°) from π∕2 (90°)"));
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* tan(x) = sin(x) / cos(x) */
+ mp_sin(x, unit, &sin_x);
+ mp_divide(&sin_x, &cos_x, z);
+}
+
+
+void
+mp_asin(const MPNumber *x, MPAngleUnit unit, MPNumber *z)
+{
+ MPNumber t1, t2;
+
+ /* asin⁻¹(0) = 0 */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* sin⁻¹(x) = tan⁻¹(x / √(1 - x²)), |x| < 1 */
+ if (x->exponent <= 0) {
+ mp_set_from_integer(1, &t1);
+ mp_set_from_mp(&t1, &t2);
+ mp_subtract(&t1, x, &t1);
+ mp_add(&t2, x, &t2);
+ mp_multiply(&t1, &t2, &t2);
+ mp_root(&t2, -2, &t2);
+ mp_multiply(x, &t2, z);
+ mp_atan(z, unit, z);
+ return;
+ }
+
+ /* sin⁻¹(1) = π/2, sin⁻¹(-1) = -π/2 */
+ mp_set_from_integer(x->sign, &t2);
+ if (mp_is_equal(x, &t2)) {
+ mp_get_pi(z);
+ mp_divide_integer(z, 2 * t2.sign, z);
+ convert_from_radians(z, unit, z);
+ return;
+ }
+
+ /* Translators: Error displayed when inverse sine value is undefined */
+ mperr(_("Inverse sine is undefined for values outside [-1, 1]"));
+ mp_set_from_integer(0, z);
+}
+
+
+void
+mp_acos(const MPNumber *x, MPAngleUnit unit, MPNumber *z)
+{
+ MPNumber t1, t2;
+ MPNumber MPn1, pi, MPy;
+
+ mp_get_pi(&pi);
+ mp_set_from_integer(1, &t1);
+ mp_set_from_integer(-1, &MPn1);
+
+ if (mp_is_greater_than(x, &t1) || mp_is_less_than(x, &MPn1)) {
+ /* Translators: Error displayed when inverse cosine value is undefined */
+ mperr(_("Inverse cosine is undefined for values outside [-1, 1]"));
+ mp_set_from_integer(0, z);
+ } else if (mp_is_zero(x)) {
+ mp_divide_integer(&pi, 2, z);
+ } else if (mp_is_equal(x, &t1)) {
+ mp_set_from_integer(0, z);
+ } else if (mp_is_equal(x, &MPn1)) {
+ mp_set_from_mp(&pi, z);
+ } else {
+ /* cos⁻¹(x) = tan⁻¹(√(1 - x²) / x) */
+ mp_multiply(x, x, &t2);
+ mp_subtract(&t1, &t2, &t2);
+ mp_sqrt(&t2, &t2);
+ mp_divide(&t2, x, &t2);
+ mp_atan(&t2, MP_RADIANS, &MPy);
+ if (x->sign > 0) {
+ mp_set_from_mp(&MPy, z);
+ } else {
+ mp_add(&MPy, &pi, z);
+ }
+ }
+
+ convert_from_radians(z, unit, z);
+}
+
+
+void
+mp_atan(const MPNumber *x, MPAngleUnit unit, MPNumber *z)
+{
+ int i, q;
+ float rx = 0.0;
+ MPNumber t1, t2;
+
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ mp_set_from_mp(x, &t2);
+ if (abs(x->exponent) <= 2)
+ rx = mp_cast_to_float(x);
+
+ /* REDUCE ARGUMENT IF NECESSARY BEFORE USING SERIES */
+ q = 1;
+ while (t2.exponent >= 0)
+ {
+ if (t2.exponent == 0 && 2 * (t2.fraction[0] + 1) <= MP_BASE)
+ break;
+
+ q *= 2;
+ 
+ /* t = t / (√(t² + 1) + 1) */
+ mp_multiply(&t2, &t2, z);
+ mp_add_integer(z, 1, z);
+ mp_sqrt(z, z);
+ mp_add_integer(z, 1, z);
+ mp_divide(&t2, z, &t2);
+ }
+
+ /* USE POWER SERIES NOW ARGUMENT IN (-0.5, 0.5) */
+ mp_set_from_mp(&t2, z);
+ mp_multiply(&t2, &t2, &t1);
+
+ /* SERIES LOOP. REDUCE T IF POSSIBLE. */
+ for (i = 1; ; i += 2) {
+ if (MP_T + 2 + t2.exponent <= 1)
+ break;
+
+ mp_multiply(&t2, &t1, &t2);
+ mp_multiply_fraction(&t2, -i, i + 2, &t2);
+
+ mp_add(z, &t2, z);
+ if (mp_is_zero(&t2))
+ break;
+ }
+
+ /* CORRECT FOR ARGUMENT REDUCTION */
+ mp_multiply_integer(z, q, z);
+
+ /* CHECK THAT RELATIVE ERROR LESS THAN 0.01 UNLESS EXPONENT
+ * OF X IS LARGE (WHEN ATAN MIGHT NOT WORK)
+ */
+ if (abs(x->exponent) <= 2) {
+ float ry = mp_cast_to_float(z);
+ /* THE FOLLOWING MESSAGE MAY INDICATE THAT B**(T-1) IS TOO SMALL. */
+ if (fabs(ry - atan(rx)) >= fabs(ry) * 0.01)
+ mperr("*** ERROR OCCURRED IN MP_ATAN, RESULT INCORRECT ***");
+ }
+
+ convert_from_radians(z, unit, z);
+}
+
+
+void
+mp_sinh(const MPNumber *x, MPNumber *z)
+{
+ MPNumber abs_x;
+
+ /* sinh(0) = 0 */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* WORK WITH ABS(X) */
+ mp_abs(x, &abs_x);
+
+ /* If |x| < 1 USE MPEXP TO AVOID CANCELLATION, otherwise IF TOO LARGE MP_EPOWY GIVES ERROR MESSAGE */
+ if (abs_x.exponent <= 0) {
+ MPNumber exp_x, a, b;
+
+ /* ((e^|x| + 1) * (e^|x| - 1)) / e^|x| */
+ // FIXME: Solves to e^|x| - e^-|x|, why not lower branch always? */
+ mp_epowy(&abs_x, &exp_x);
+ mp_add_integer(&exp_x, 1, &a);
+ mp_add_integer(&exp_x, -1, &b);
+ mp_multiply(&a, &b, z);
+ mp_divide(z, &exp_x, z);
+ }
+ else {
+ MPNumber exp_x;
+
+ /* e^|x| - e^-|x| */
+ mp_epowy(&abs_x, &exp_x);
+ mp_reciprocal(&exp_x, z);
+ mp_subtract(&exp_x, z, z);
+ }
+
+ /* DIVIDE BY TWO AND RESTORE SIGN */
+ mp_divide_integer(z, 2, z);
+ mp_multiply_integer(z, x->sign, z);
+}
+
+
+void
+mp_cosh(const MPNumber *x, MPNumber *z)
+{
+ MPNumber t;
+
+ /* cosh(0) = 1 */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(1, z);
+ return;
+ }
+
+ /* cosh(x) = (e^x + e^-x) / 2 */
+ mp_abs(x, &t);
+ mp_epowy(&t, &t);
+ mp_reciprocal(&t, z);
+ mp_add(&t, z, z);
+ mp_divide_integer(z, 2, z);
+}
+
+
+void
+mp_tanh(const MPNumber *x, MPNumber *z)
+{
+ float r__1;
+ MPNumber t;
+
+ /* tanh(0) = 0 */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ mp_abs(x, &t);
+
+ /* SEE IF ABS(X) SO LARGE THAT RESULT IS +-1 */
+ r__1 = (float) MP_T * 0.5 * log((float) MP_BASE);
+ mp_set_from_float(r__1, z);
+ if (mp_compare_mp_to_mp(&t, z) > 0) {
+ mp_set_from_integer(x->sign, z);
+ return;
+ }
+
+ /* If |x| >= 1/2 use ?, otherwise use ? to avoid cancellation */
+ /* |tanh(x)| = (e^|2x| - 1) / (e^|2x| + 1) */
+ mp_multiply_integer(&t, 2, &t);
+ if (t.exponent > 0) {
+ mp_epowy(&t, &t);
+ mp_add_integer(&t, -1, z);
+ mp_add_integer(&t, 1, &t);
+ mp_divide(z, &t, z);
+ } else {
+ mp_epowy(&t, &t);
+ mp_add_integer(&t, 1, z);
+ mp_divide(&t, z, z);
+ }
+
+ /* Restore sign */
+ z->sign = x->sign * z->sign;
+}
+
+
+void
+mp_asinh(const MPNumber *x, MPNumber *z)
+{
+ MPNumber t;
+
+ /* sinh⁻¹(x) = ln(x + √(x² + 1)) */
+ mp_multiply(x, x, &t);
+ mp_add_integer(&t, 1, &t);
+ mp_sqrt(&t, &t);
+ mp_add(x, &t, &t);
+ mp_ln(&t, z);
+}
+
+
+void
+mp_acosh(const MPNumber *x, MPNumber *z)
+{
+ MPNumber t;
+
+ /* Check x >= 1 */
+ mp_set_from_integer(1, &t);
+ if (mp_is_less_than(x, &t)) {
+ /* Translators: Error displayed when inverse hyperbolic cosine value is undefined */
+ mperr(_("Inverse hyperbolic cosine is undefined for values less than or equal to one"));
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* cosh⁻¹(x) = ln(x + √(x² - 1)) */
+ mp_multiply(x, x, &t);
+ mp_add_integer(&t, -1, &t);
+ mp_sqrt(&t, &t);
+ mp_add(x, &t, &t);
+ mp_ln(&t, z);
+}
+
+
+void
+mp_atanh(const MPNumber *x, MPNumber *z)
+{
+ MPNumber one, minus_one, n, d;
+
+ /* Check -1 <= x <= 1 */
+ mp_set_from_integer(1, &one);
+ mp_set_from_integer(-1, &minus_one);
+ if (mp_is_greater_equal(x, &one) || mp_is_less_equal(x, &minus_one)) {
+ /* Translators: Error displayed when inverse hyperbolic tangent value is undefined */
+ mperr(_("Inverse hyperbolic tangent is undefined for values outside [-1, 1]"));
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* atanh(x) = 0.5 * ln((1 + x) / (1 - x)) */
+ mp_add_integer(x, 1, &n);
+ mp_set_from_mp(x, &d);
+ mp_invert_sign(&d, &d);
+ mp_add_integer(&d, 1, &d);
+ mp_divide(&n, &d, z);
+ mp_ln(z, z);
+ mp_divide_integer(z, 2, z);
+}
diff --git a/src/mp.c b/src/mp.c
new file mode 100644
index 0000000..0e46b35
--- /dev/null
+++ b/src/mp.c
@@ -0,0 +1,2092 @@
+/* Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <errno.h>
+
+#include "mp.h"
+#include "mp-private.h"
+
+// FIXME: Re-add overflow and underflow detection
+
+char *mp_error = NULL;
+
+/* THIS ROUTINE IS CALLED WHEN AN ERROR CONDITION IS ENCOUNTERED, AND
+ * AFTER A MESSAGE HAS BEEN WRITTEN TO STDERR.
+ */
+void
+mperr(const char *format, ...)
+{
+ char text[1024];
+ va_list args;
+
+ va_start(args, format);
+ vsnprintf(text, 1024, format, args);
+ va_end(args);
+
+ if (mp_error)
+ free(mp_error);
+ mp_error = strdup(text);
+}
+
+
+const char *
+mp_get_error()
+{
+ return mp_error;
+}
+
+
+void mp_clear_error()
+{
+ if (mp_error)
+ free(mp_error);
+ mp_error = NULL;
+}
+
+
+/* ROUTINE CALLED BY MP_DIVIDE AND MP_SQRT TO ENSURE THAT
+ * RESULTS ARE REPRESENTED EXACTLY IN T-2 DIGITS IF THEY
+ * CAN BE. X IS AN MP NUMBER, I AND J ARE INTEGERS.
+ */
+static void
+mp_ext(int i, int j, MPNumber *x)
+{
+ int q, s;
+
+ if (mp_is_zero(x) || MP_T <= 2 || i == 0)
+ return;
+
+ /* COMPUTE MAXIMUM POSSIBLE ERROR IN THE LAST PLACE */
+ q = (j + 1) / i + 1;
+ s = MP_BASE * x->fraction[MP_T - 2] + x->fraction[MP_T - 1];
+
+ /* SET LAST TWO DIGITS TO ZERO */
+ if (s <= q) {
+ x->fraction[MP_T - 2] = 0;
+ x->fraction[MP_T - 1] = 0;
+ return;
+ }
+
+ if (s + q < MP_BASE * MP_BASE)
+ return;
+
+ /* ROUND UP HERE */
+ x->fraction[MP_T - 2] = MP_BASE - 1;
+ x->fraction[MP_T - 1] = MP_BASE;
+
+ /* NORMALIZE X (LAST DIGIT B IS OK IN MP_MULTIPLY_INTEGER) */
+ mp_multiply_integer(x, 1, x);
+}
+
+
+void
+mp_get_eulers(MPNumber *z)
+{
+ MPNumber t;
+ mp_set_from_integer(1, &t);
+ mp_epowy(&t, z);
+}
+
+
+void
+mp_get_i(MPNumber *z)
+{
+ mp_set_from_integer(0, z);
+ z->im_sign = 1;
+ z->im_exponent = 1;
+ z->im_fraction[0] = 1;
+}
+
+
+void
+mp_abs(const MPNumber *x, MPNumber *z)
+{
+ if (mp_is_complex(x)){
+ MPNumber x_real, x_im;
+
+ mp_real_component(x, &x_real);
+ mp_imaginary_component(x, &x_im);
+
+ mp_multiply(&x_real, &x_real, &x_real);
+ mp_multiply(&x_im, &x_im, &x_im);
+ mp_add(&x_real, &x_im, z);
+ mp_root(z, 2, z);
+ }
+ else {
+ mp_set_from_mp(x, z);
+ if (z->sign < 0)
+ z->sign = -z->sign;
+ }
+}
+
+
+void
+mp_arg(const MPNumber *x, MPAngleUnit unit, MPNumber *z)
+{
+ MPNumber x_real, x_im, pi;
+
+ if (mp_is_zero(x)) {
+ /* Translators: Error display when attempting to take argument of zero */
+ mperr(_("Argument not defined for zero"));
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ mp_real_component(x, &x_real);
+ mp_imaginary_component(x, &x_im);
+ mp_get_pi(&pi);
+
+ if (mp_is_zero(&x_im)) {
+ if (mp_is_negative(&x_real))
+ convert_from_radians(&pi, MP_RADIANS, z);
+ else
+ mp_set_from_integer(0, z);
+ }
+ else if (mp_is_zero(&x_real)) {
+ mp_set_from_mp(&pi, z);
+ if (mp_is_negative(&x_im))
+ mp_divide_integer(z, -2, z);
+ else
+ mp_divide_integer(z, 2, z);
+ }
+ else if (mp_is_negative(&x_real)) {
+ mp_divide(&x_im, &x_real, z);
+ mp_atan(z, MP_RADIANS, z);
+ if (mp_is_negative(&x_im))
+ mp_subtract(z, &pi, z);
+ else
+ mp_add(z, &pi, z);
+ }
+ else {
+ mp_divide(&x_im, &x_real, z);
+ mp_atan(z, MP_RADIANS, z);
+ }
+
+ convert_from_radians(z, unit, z);
+}
+
+
+void
+mp_conjugate(const MPNumber *x, MPNumber *z)
+{
+ mp_set_from_mp(x, z);
+ z->im_sign = -z->im_sign;
+}
+
+
+void
+mp_real_component(const MPNumber *x, MPNumber *z)
+{
+ mp_set_from_mp(x, z);
+
+ /* Clear imaginary component */
+ z->im_sign = 0;
+ z->im_exponent = 0;
+ memset(z->im_fraction, 0, sizeof(int) * MP_SIZE);
+}
+
+
+void
+mp_imaginary_component(const MPNumber *x, MPNumber *z)
+{
+ /* Copy imaginary component to real component */
+ z->sign = x->im_sign;
+ z->exponent = x->im_exponent;
+ memcpy(z->fraction, x->im_fraction, sizeof(int) * MP_SIZE);
+ 
+ /* Clear (old) imaginary component */ 
+ z->im_sign = 0;
+ z->im_exponent = 0;
+ memset(z->im_fraction, 0, sizeof(int) * MP_SIZE);
+}
+
+
+static void
+mp_add_real(const MPNumber *x, int y_sign, const MPNumber *y, MPNumber *z)
+{
+ int sign_prod, i, c;
+ int exp_diff, med;
+ bool x_largest = false;
+ const int *big_fraction, *small_fraction;
+ MPNumber x_copy, y_copy;
+
+ /* 0 + y = y */
+ if (mp_is_zero(x)) {
+ mp_set_from_mp(y, z);
+ z->sign = y_sign;
+ return;
+ }
+ /* x + 0 = x */ 
+ else if (mp_is_zero(y)) {
+ mp_set_from_mp(x, z);
+ return;
+ }
+
+ sign_prod = y_sign * x->sign;
+ exp_diff = x->exponent - y->exponent;
+ med = abs(exp_diff);
+ if (exp_diff < 0) {
+ x_largest = false;
+ } else if (exp_diff > 0) {
+ x_largest = true;
+ } else {
+ /* EXPONENTS EQUAL SO COMPARE SIGNS, THEN FRACTIONS IF NEC. */
+ if (sign_prod < 0) {
+ /* Signs are not equal. find out which mantissa is larger. */
+ int j;
+ for (j = 0; j < MP_T; j++) {
+ int i = x->fraction[j] - y->fraction[j];
+ if (i == 0)
+ continue;
+ if (i < 0)
+ x_largest = false;
+ else if (i > 0)
+ x_largest = true;
+ break;
+ }
+
+ /* Both mantissas equal, so result is zero. */
+ if (j >= MP_T) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+ }
+ }
+
+ mp_set_from_mp(x, &x_copy);
+ mp_set_from_mp(y, &y_copy);
+ mp_set_from_integer(0, z);
+
+ if (x_largest) {
+ z->sign = x_copy.sign;
+ z->exponent = x_copy.exponent;
+ big_fraction = x_copy.fraction;
+ small_fraction = y_copy.fraction;
+ } else {
+ z->sign = y_sign;
+ z->exponent = y_copy.exponent;
+ big_fraction = y_copy.fraction;
+ small_fraction = x_copy.fraction;
+ }
+
+ /* CLEAR GUARD DIGITS TO RIGHT OF X DIGITS */
+ for(i = 3; i >= med; i--)
+ z->fraction[MP_T + i] = 0;
+
+ if (sign_prod >= 0) {
+ /* HERE DO ADDITION, EXPONENT(Y) >= EXPONENT(X) */
+ for (i = MP_T + 3; i >= MP_T; i--)
+ z->fraction[i] = small_fraction[i - med];
+
+ c = 0;
+ for (; i >= med; i--) {
+ c = big_fraction[i] + small_fraction[i - med] + c;
+
+ if (c < MP_BASE) {
+ /* NO CARRY GENERATED HERE */
+ z->fraction[i] = c;
+ c = 0;
+ } else {
+ /* CARRY GENERATED HERE */
+ z->fraction[i] = c - MP_BASE;
+ c = 1;
+ }
+ }
+
+ for (; i >= 0; i--)
+ {
+ c = big_fraction[i] + c;
+ if (c < MP_BASE) {
+ z->fraction[i] = c;
+ i--;
+
+ /* NO CARRY POSSIBLE HERE */
+ for (; i >= 0; i--)
+ z->fraction[i] = big_fraction[i];
+
+ c = 0;
+ break;
+ }
+
+ z->fraction[i] = 0;
+ c = 1;
+ }
+
+ /* MUST SHIFT RIGHT HERE AS CARRY OFF END */
+ if (c != 0) {
+ for (i = MP_T + 3; i > 0; i--)
+ z->fraction[i] = z->fraction[i - 1];
+ z->fraction[0] = 1;
+ z->exponent++;
+ }
+ }
+ else {
+ c = 0;
+ for (i = MP_T + med - 1; i >= MP_T; i--) {
+ /* HERE DO SUBTRACTION, ABS(Y) > ABS(X) */
+ z->fraction[i] = c - small_fraction[i - med];
+ c = 0;
+
+ /* BORROW GENERATED HERE */
+ if (z->fraction[i] < 0) {
+ c = -1;
+ z->fraction[i] += MP_BASE;
+ }
+ }
+
+ for(; i >= med; i--) {
+ c = big_fraction[i] + c - small_fraction[i - med];
+ if (c >= 0) {
+ /* NO BORROW GENERATED HERE */
+ z->fraction[i] = c;
+ c = 0;
+ } else {
+ /* BORROW GENERATED HERE */
+ z->fraction[i] = c + MP_BASE;
+ c = -1;
+ }
+ }
+
+ for (; i >= 0; i--) {
+ c = big_fraction[i] + c;
+
+ if (c >= 0) {
+ z->fraction[i] = c;
+ i--;
+
+ /* NO CARRY POSSIBLE HERE */
+ for (; i >= 0; i--)
+ z->fraction[i] = big_fraction[i];
+
+ break;
+ }
+
+ z->fraction[i] = c + MP_BASE;
+ c = -1;
+ }
+ }
+
+ mp_normalize(z);
+}
+
+
+static void
+mp_add_with_sign(const MPNumber *x, int y_sign, const MPNumber *y, MPNumber *z)
+{
+ if (mp_is_complex(x) || mp_is_complex(y)) {
+ MPNumber real_x, real_y, im_x, im_y, real_z, im_z;
+
+ mp_real_component(x, &real_x);
+ mp_imaginary_component(x, &im_x);
+ mp_real_component(y, &real_y);
+ mp_imaginary_component(y, &im_y);
+
+ mp_add_real(&real_x, y_sign * y->sign, &real_y, &real_z);
+ mp_add_real(&im_x, y_sign * y->im_sign, &im_y, &im_z);
+
+ mp_set_from_complex(&real_z, &im_z, z);
+ }
+ else
+ mp_add_real(x, y_sign * y->sign, y, z);
+}
+
+
+void
+mp_add(const MPNumber *x, const MPNumber *y, MPNumber *z)
+{
+ mp_add_with_sign(x, 1, y, z);
+}
+
+
+void
+mp_add_integer(const MPNumber *x, int64_t y, MPNumber *z)
+{
+ MPNumber t;
+ mp_set_from_integer(y, &t);
+ mp_add(x, &t, z);
+}
+
+
+void
+mp_add_fraction(const MPNumber *x, int64_t i, int64_t j, MPNumber *y)
+{
+ MPNumber t;
+ mp_set_from_fraction(i, j, &t);
+ mp_add(x, &t, y);
+}
+
+
+void
+mp_subtract(const MPNumber *x, const MPNumber *y, MPNumber *z)
+{
+ mp_add_with_sign(x, -1, y, z);
+}
+
+
+void
+mp_sgn(const MPNumber *x, MPNumber *z)
+{
+ if (mp_is_zero(x))
+ mp_set_from_integer(0, z);
+ else if (mp_is_negative(x))
+ mp_set_from_integer(-1, z);
+ else
+ mp_set_from_integer(1, z); 
+}
+
+void
+mp_integer_component(const MPNumber *x, MPNumber *z)
+{
+ int i;
+
+ /* Clear fraction */
+ mp_set_from_mp(x, z);
+ for (i = z->exponent; i < MP_SIZE; i++)
+ z->fraction[i] = 0;
+ z->im_sign = 0;
+ z->im_exponent = 0;
+ memset(z->im_fraction, 0, sizeof(int) * MP_SIZE);
+}
+
+void
+mp_fractional_component(const MPNumber *x, MPNumber *z)
+{
+ int i, shift;
+
+ /* Fractional component of zero is 0 */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* All fractional */
+ if (x->exponent <= 0) {
+ mp_set_from_mp(x, z);
+ return;
+ }
+
+ /* Shift fractional component */
+ shift = x->exponent;
+ for (i = shift; i < MP_SIZE && x->fraction[i] == 0; i++)
+ shift++;
+ z->sign = x->sign;
+ z->exponent = x->exponent - shift;
+ for (i = 0; i < MP_SIZE; i++) {
+ if (i + shift >= MP_SIZE)
+ z->fraction[i] = 0;
+ else
+ z->fraction[i] = x->fraction[i + shift];
+ }
+ if (z->fraction[0] == 0)
+ z->sign = 0;
+
+ z->im_sign = 0;
+ z->im_exponent = 0;
+ memset(z->im_fraction, 0, sizeof(int) * MP_SIZE);
+}
+
+
+void
+mp_fractional_part(const MPNumber *x, MPNumber *z)
+{
+ MPNumber f;
+ mp_floor(x, &f);
+ mp_subtract(x, &f, z);
+}
+
+
+void
+mp_floor(const MPNumber *x, MPNumber *z)
+{
+ int i;
+ bool have_fraction = false, is_negative;
+
+ /* Integer component of zero = 0 */
+ if (mp_is_zero(x)) {
+ mp_set_from_mp(x, z);
+ return;
+ }
+
+ /* If all fractional then no integer component */
+ if (x->exponent <= 0) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ is_negative = mp_is_negative(x);
+
+ /* Clear fraction */
+ mp_set_from_mp(x, z);
+ for (i = z->exponent; i < MP_SIZE; i++) {
+ if (z->fraction[i])
+ have_fraction = true;
+ z->fraction[i] = 0;
+ }
+ z->im_sign = 0;
+ z->im_exponent = 0;
+ memset(z->im_fraction, 0, sizeof(int) * MP_SIZE);
+
+ if (have_fraction && is_negative)
+ mp_add_integer(z, -1, z);
+}
+
+
+void
+mp_ceiling(const MPNumber *x, MPNumber *z)
+{
+ MPNumber f;
+
+ mp_floor(x, z);
+ mp_fractional_component(x, &f);
+ if (mp_is_zero(&f))
+ return;
+ mp_add_integer(z, 1, z);
+}
+
+
+void
+mp_round(const MPNumber *x, MPNumber *z)
+{
+ MPNumber f, one;
+ bool do_floor;
+
+ do_floor = !mp_is_negative(x);
+
+ mp_fractional_component(x, &f);
+ mp_multiply_integer(&f, 2, &f);
+ mp_abs(&f, &f);
+ mp_set_from_integer(1, &one);
+ if (mp_is_greater_equal(&f, &one))
+ do_floor = !do_floor;
+
+ if (do_floor)
+ mp_floor(x, z);
+ else
+ mp_ceiling(x, z);
+}
+
+int
+mp_compare_mp_to_mp(const MPNumber *x, const MPNumber *y)
+{
+ int i;
+
+ if (x->sign != y->sign) {
+ if (x->sign > y->sign)
+ return 1;
+ else
+ return -1;
+ }
+
+ /* x = y = 0 */
+ if (mp_is_zero(x))
+ return 0;
+
+ /* See if numbers are of different magnitude */
+ if (x->exponent != y->exponent) {
+ if (x->exponent > y->exponent)
+ return x->sign;
+ else
+ return -x->sign;
+ }
+
+ /* Compare fractions */
+ for (i = 0; i < MP_SIZE; i++) {
+ if (x->fraction[i] == y->fraction[i])
+ continue;
+
+ if (x->fraction[i] > y->fraction[i])
+ return x->sign;
+ else
+ return -x->sign;
+ }
+
+ /* x = y */
+ return 0;
+}
+
+
+void
+mp_divide(const MPNumber *x, const MPNumber *y, MPNumber *z)
+{
+ int i, ie;
+ MPNumber t;
+
+ /* x/0 */
+ if (mp_is_zero(y)) {
+ /* Translators: Error displayed attempted to divide by zero */
+ mperr(_("Division by zero is undefined"));
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* 0/y = 0 */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* z = x × y⁻¹ */
+ /* FIXME: Set exponent to zero to avoid overflow in mp_multiply??? */
+ mp_reciprocal(y, &t);
+ ie = t.exponent;
+ t.exponent = 0;
+ i = t.fraction[0];
+ mp_multiply(x, &t, z);
+ mp_ext(i, z->fraction[0], z);
+ z->exponent += ie;
+}
+
+
+static void
+mp_divide_integer_real(const MPNumber *x, int64_t y, MPNumber *z)
+{
+ int c, i, k, b2, c2, j1, j2;
+ MPNumber x_copy;
+
+ /* x/0 */
+ if (y == 0) {
+ /* Translators: Error displayed attempted to divide by zero */
+ mperr(_("Division by zero is undefined"));
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* 0/y = 0 */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* Division by -1 or 1 just changes sign */
+ if (y == 1 || y == -1) {
+ if (y < 0)
+ mp_invert_sign(x, z);
+ else
+ mp_set_from_mp(x, z);
+ return;
+ }
+
+ /* Copy x as z may also refer to x */
+ mp_set_from_mp(x, &x_copy);
+ mp_set_from_integer(0, z);
+
+ if (y < 0) {
+ y = -y;
+ z->sign = -x_copy.sign;
+ }
+ else
+ z->sign = x_copy.sign;
+ z->exponent = x_copy.exponent;
+
+ c = 0;
+ i = 0;
+
+ /* IF y*B NOT REPRESENTABLE AS AN INTEGER HAVE TO SIMULATE
+ * LONG DIVISION. ASSUME AT LEAST 16-BIT WORD.
+ */
+
+ /* Computing MAX */
+ b2 = max(MP_BASE << 3, 32767 / MP_BASE);
+ if (y < b2) {
+ int kh, r1;
+
+ /* LOOK FOR FIRST NONZERO DIGIT IN QUOTIENT */
+ do {
+ c = MP_BASE * c;
+ if (i < MP_T)
+ c += x_copy.fraction[i];
+ i++;
+ r1 = c / y;
+ if (r1 < 0)
+ goto L210;
+ } while (r1 == 0);
+
+ /* ADJUST EXPONENT AND GET T+4 DIGITS IN QUOTIENT */
+ z->exponent += 1 - i;
+ z->fraction[0] = r1;
+ c = MP_BASE * (c - y * r1);
+ kh = 1;
+ if (i < MP_T) {
+ kh = MP_T + 1 - i;
+ for (k = 1; k < kh; k++) {
+ c += x_copy.fraction[i];
+ z->fraction[k] = c / y;
+ c = MP_BASE * (c - y * z->fraction[k]);
+ i++;
+ }
+ if (c < 0)
+ goto L210;
+ }
+
+ for (k = kh; k < MP_T + 4; k++) {
+ z->fraction[k] = c / y;
+ c = MP_BASE * (c - y * z->fraction[k]);
+ }
+ if (c < 0)
+ goto L210;
+
+ mp_normalize(z);
+ return;
+ }
+
+ /* HERE NEED SIMULATED DOUBLE-PRECISION DIVISION */
+ j1 = y / MP_BASE;
+ j2 = y - j1 * MP_BASE;
+
+ /* LOOK FOR FIRST NONZERO DIGIT */
+ c2 = 0;
+ do {
+ c = MP_BASE * c + c2;
+ c2 = i < MP_T ? x_copy.fraction[i] : 0;
+ i++;
+ } while (c < j1 || (c == j1 && c2 < j2));
+
+ /* COMPUTE T+4 QUOTIENT DIGITS */
+ z->exponent += 1 - i;
+ i--;
+
+ /* MAIN LOOP FOR LARGE ABS(y) CASE */
+ for (k = 1; k <= MP_T + 4; k++) {
+ int ir, iq, iqj;
+
+ /* GET APPROXIMATE QUOTIENT FIRST */
+ ir = c / (j1 + 1);
+
+ /* NOW REDUCE SO OVERFLOW DOES NOT OCCUR */
+ iq = c - ir * j1;
+ if (iq >= b2) {
+ /* HERE IQ*B WOULD POSSIBLY OVERFLOW SO INCREASE IR */
+ ++ir;
+ iq -= j1;
+ }
+
+ iq = iq * MP_BASE - ir * j2;
+ if (iq < 0) {
+ /* HERE IQ NEGATIVE SO IR WAS TOO LARGE */
+ ir--;
+ iq += y;
+ }
+
+ if (i < MP_T)
+ iq += x_copy.fraction[i];
+ i++;
+ iqj = iq / y;
+
+ /* R(K) = QUOTIENT, C = REMAINDER */
+ z->fraction[k - 1] = iqj + ir;
+ c = iq - y * iqj;
+
+ if (c < 0)
+ goto L210;
+ }
+
+ mp_normalize(z);
+
+L210:
+ /* CARRY NEGATIVE SO OVERFLOW MUST HAVE OCCURRED */
+ mperr("*** INTEGER OVERFLOW IN MP_DIVIDE_INTEGER, B TOO LARGE ***");
+ mp_set_from_integer(0, z);
+}
+
+
+void
+mp_divide_integer(const MPNumber *x, int64_t y, MPNumber *z)
+{
+ if (mp_is_complex(x)) {
+ MPNumber re_z, im_z;
+
+ mp_real_component(x, &re_z);
+ mp_imaginary_component(x, &im_z);
+ mp_divide_integer_real(&re_z, y, &re_z);
+ mp_divide_integer_real(&im_z, y, &im_z);
+ mp_set_from_complex(&re_z, &im_z, z);
+ }
+ else
+ mp_divide_integer_real(x, y, z);
+}
+
+
+bool
+mp_is_integer(const MPNumber *x)
+{
+ MPNumber t1, t2, t3;
+ 
+ if (mp_is_complex(x))
+ return false;
+
+ /* This fix is required for 1/3 repiprocal not being detected as an integer */
+ /* Multiplication and division by 10000 is used to get around a
+ * limitation to the "fix" for Sun bugtraq bug #4006391 in the
+ * mp_floor() routine in mp.c, when the exponent is less than 1.
+ */
+ mp_set_from_integer(10000, &t3);
+ mp_multiply(x, &t3, &t1);
+ mp_divide(&t1, &t3, &t1);
+ mp_floor(&t1, &t2);
+ return mp_is_equal(&t1, &t2);
+
+ /* Correct way to check for integer */
+ /*int i;
+
+ // Zero is an integer
+ if (mp_is_zero(x))
+ return true;
+
+ // Fractional
+ if (x->exponent <= 0)
+ return false;
+
+ // Look for fractional components
+ for (i = x->exponent; i < MP_SIZE; i++) {
+ if (x->fraction[i] != 0)
+ return false;
+ }
+
+ return true;*/
+}
+
+
+bool
+mp_is_positive_integer(const MPNumber *x)
+{
+ if (mp_is_complex(x))
+ return false;
+ else
+ return x->sign >= 0 && mp_is_integer(x);
+}
+
+
+bool
+mp_is_natural(const MPNumber *x)
+{
+ if (mp_is_complex(x))
+ return false;
+ else
+ return x->sign > 0 && mp_is_integer(x);
+}
+
+
+bool
+mp_is_complex(const MPNumber *x)
+{
+ return x->im_sign != 0;
+}
+
+
+bool
+mp_is_equal(const MPNumber *x, const MPNumber *y)
+{
+ return mp_compare_mp_to_mp(x, y) == 0;
+}
+
+
+/* Return e^x for |x| < 1 USING AN O(SQRT(T).M(T)) ALGORITHM
+ * DESCRIBED IN - R. P. BRENT, THE COMPLEXITY OF MULTIPLE-
+ * PRECISION ARITHMETIC (IN COMPLEXITY OF COMPUTATIONAL PROBLEM
+ * SOLVING, UNIV. OF QUEENSLAND PRESS, BRISBANE, 1976, 126-165).
+ * ASYMPTOTICALLY FASTER METHODS EXIST, BUT ARE NOT USEFUL
+ * UNLESS T IS VERY LARGE. SEE COMMENTS TO MP_ATAN AND MPPIGL.
+ */
+static void
+mp_exp(const MPNumber *x, MPNumber *z)
+{
+ int i, q;
+ float rlb;
+ MPNumber t1, t2;
+
+ /* e^0 = 1 */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(1, z);
+ return;
+ }
+
+ /* Only defined for |x| < 1 */
+ if (x->exponent > 0) {
+ mperr("*** ABS(X) NOT LESS THAN 1 IN CALL TO MP_EXP ***");
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ mp_set_from_mp(x, &t1);
+ rlb = log((float)MP_BASE);
+
+ /* Compute approximately optimal q (and divide x by 2^q) */
+ q = (int)(sqrt((float)MP_T * 0.48f * rlb) + (float) x->exponent * 1.44f * rlb);
+
+ /* HALVE Q TIMES */
+ if (q > 0) {
+ int ib, ic;
+
+ ib = MP_BASE << 2;
+ ic = 1;
+ for (i = 1; i <= q; ++i) {
+ ic *= 2;
+ if (ic < ib && ic != MP_BASE && i < q)
+ continue;
+ mp_divide_integer(&t1, ic, &t1);
+ ic = 1;
+ }
+ }
+
+ if (mp_is_zero(&t1)) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* Sum series, reducing t where possible */
+ mp_set_from_mp(&t1, z);
+ mp_set_from_mp(&t1, &t2);
+ for (i = 2; MP_T + t2.exponent - z->exponent > 0; i++) {
+ mp_multiply(&t1, &t2, &t2);
+ mp_divide_integer(&t2, i, &t2);
+ mp_add(&t2, z, z);
+ if (mp_is_zero(&t2))
+ break;
+ }
+
+ /* Apply (x+1)^2 - 1 = x(2 + x) for q iterations */
+ for (i = 1; i <= q; ++i) {
+ mp_add_integer(z, 2, &t1);
+ mp_multiply(&t1, z, z);
+ }
+
+ mp_add_integer(z, 1, z);
+}
+
+
+static void
+mp_epowy_real(const MPNumber *x, MPNumber *z)
+{
+ float r__1;
+ int i, ix, xs, tss;
+ float rx, rz, rlb;
+ MPNumber t1, t2;
+
+ /* e^0 = 1 */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(1, z);
+ return;
+ }
+
+ /* If |x| < 1 use mp_exp */
+ if (x->exponent <= 0) {
+ mp_exp(x, z);
+ return;
+ }
+
+ /* SEE IF ABS(X) SO LARGE THAT EXP(X) WILL CERTAINLY OVERFLOW
+ * OR UNDERFLOW. 1.01 IS TO ALLOW FOR ERRORS IN ALOG.
+ */
+ rlb = log((float)MP_BASE) * 1.01f;
+
+ /* NOW SAFE TO CONVERT X TO REAL */
+ rx = mp_cast_to_float(x);
+
+ /* SAVE SIGN AND WORK WITH ABS(X) */
+ xs = x->sign;
+ mp_abs(x, &t2);
+
+ /* GET FRACTIONAL AND INTEGER PARTS OF ABS(X) */
+ ix = mp_cast_to_int(&t2);
+ mp_fractional_component(&t2, &t2);
+
+ /* ATTACH SIGN TO FRACTIONAL PART AND COMPUTE EXP OF IT */
+ t2.sign *= xs;
+ mp_exp(&t2, z);
+
+ /* COMPUTE E-2 OR 1/E USING TWO EXTRA DIGITS IN CASE ABS(X) LARGE
+ * (BUT ONLY ONE EXTRA DIGIT IF T < 4)
+ */
+ if (MP_T < 4)
+ tss = MP_T + 1;
+ else
+ tss = MP_T + 2;
+
+ /* LOOP FOR E COMPUTATION. DECREASE T IF POSSIBLE. */
+ /* Computing MIN */
+ mp_set_from_integer(xs, &t1);
+
+ t2.sign = 0;
+ for (i = 2 ; ; i++) {
+ if (min(tss, tss + 2 + t1.exponent) <= 2)
+ break;
+
+ mp_divide_integer(&t1, i * xs, &t1);
+ mp_add(&t2, &t1, &t2);
+ if (mp_is_zero(&t1))
+ break;
+ }
+
+ /* RAISE E OR 1/E TO POWER IX */
+ if (xs > 0)
+ mp_add_integer(&t2, 2, &t2);
+ mp_xpowy_integer(&t2, ix, &t2);
+
+ /* MULTIPLY EXPS OF INTEGER AND FRACTIONAL PARTS */
+ mp_multiply(z, &t2, z);
+
+ /* CHECK THAT RELATIVE ERROR LESS THAN 0.01 UNLESS ABS(X) LARGE
+ * (WHEN EXP MIGHT OVERFLOW OR UNDERFLOW)
+ */
+ if (fabs(rx) > 10.0f)
+ return;
+
+ rz = mp_cast_to_float(z);
+ r__1 = rz - exp(rx);
+ if (fabs(r__1) < rz * 0.01f)
+ return;
+
+ /* THE FOLLOWING MESSAGE MAY INDICATE THAT
+ * B**(T-1) IS TOO SMALL, OR THAT M IS TOO SMALL SO THE
+ * RESULT UNDERFLOWED.
+ */
+ mperr("*** ERROR OCCURRED IN MP_EPOWY, RESULT INCORRECT ***");
+}
+
+
+void
+mp_epowy(const MPNumber *x, MPNumber *z)
+{
+ /* e^0 = 1 */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(1, z);
+ return;
+ }
+
+ if (mp_is_complex(x)) {
+ MPNumber x_real, r, theta;
+
+ mp_real_component(x, &x_real);
+ mp_imaginary_component(x, &theta);
+
+ mp_epowy_real(&x_real, &r);
+ mp_set_from_polar(&r, MP_RADIANS, &theta, z);
+ }
+ else
+ mp_epowy_real(x, z);
+}
+
+
+/* RETURNS K = K/GCD AND L = L/GCD, WHERE GCD IS THE
+ * GREATEST COMMON DIVISOR OF K AND L.
+ * SAVE INPUT PARAMETERS IN LOCAL VARIABLES
+ */
+void
+mp_gcd(int64_t *k, int64_t *l)
+{
+ int64_t i, j;
+
+ i = abs(*k);
+ j = abs(*l);
+ if (j == 0) {
+ /* IF J = 0 RETURN (1, 0) UNLESS I = 0, THEN (0, 0) */
+ *k = 1;
+ *l = 0;
+ if (i == 0)
+ *k = 0;
+ return;
+ }
+
+ /* EUCLIDEAN ALGORITHM LOOP */
+ do {
+ i %= j;
+ if (i == 0) {
+ *k = *k / j;
+ *l = *l / j;
+ return;
+ }
+ j %= i;
+ } while (j != 0);
+
+ /* HERE J IS THE GCD OF K AND L */
+ *k = *k / i;
+ *l = *l / i;
+}
+
+
+bool
+mp_is_zero(const MPNumber *x)
+{
+ return x->sign == 0 && x->im_sign == 0;
+}
+
+
+bool
+mp_is_negative(const MPNumber *x)
+{
+ return x->sign < 0;
+}
+
+
+bool
+mp_is_greater_equal(const MPNumber *x, const MPNumber *y)
+{
+ return mp_compare_mp_to_mp(x, y) >= 0;
+}
+
+
+bool
+mp_is_greater_than(const MPNumber *x, const MPNumber *y)
+{
+ return mp_compare_mp_to_mp(x, y) > 0;
+}
+
+
+bool
+mp_is_less_equal(const MPNumber *x, const MPNumber *y)
+{
+ return mp_compare_mp_to_mp(x, y) <= 0;
+}
+
+
+/* RETURNS MP Y = LN(1+X) IF X IS AN MP NUMBER SATISFYING THE
+ * CONDITION ABS(X) < 1/B, ERROR OTHERWISE.
+ * USES NEWTONS METHOD TO SOLVE THE EQUATION
+ * EXP1(-Y) = X, THEN REVERSES SIGN OF Y.
+ */
+static void
+mp_lns(const MPNumber *x, MPNumber *z)
+{
+ int t, it0;
+ MPNumber t1, t2, t3;
+
+ /* ln(1+0) = 0 */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* Get starting approximation -ln(1+x) ~= -x + x^2/2 - x^3/3 + x^4/4 */
+ mp_set_from_mp(x, &t2);
+ mp_divide_integer(x, 4, &t1);
+ mp_add_fraction(&t1, -1, 3, &t1);
+ mp_multiply(x, &t1, &t1);
+ mp_add_fraction(&t1, 1, 2, &t1);
+ mp_multiply(x, &t1, &t1);
+ mp_add_integer(&t1, -1, &t1);
+ mp_multiply(x, &t1, z);
+
+ /* Solve using Newtons method */
+ it0 = t = 5;
+ while(1)
+ {
+ int ts2, ts3;
+
+ /* t3 = (e^t3 - 1) */
+ /* z = z - (t2 + t3 + (t2 * t3)) */
+ mp_epowy(z, &t3);
+ mp_add_integer(&t3, -1, &t3);
+ mp_multiply(&t2, &t3, &t1);
+ mp_add(&t3, &t1, &t3);
+ mp_add(&t2, &t3, &t3);
+ mp_subtract(z, &t3, z);
+ if (t >= MP_T)
+ break;
+
+ /* FOLLOWING LOOP COMPUTES NEXT VALUE OF T TO USE.
+ * BECAUSE NEWTONS METHOD HAS 2ND ORDER CONVERGENCE,
+ * WE CAN ALMOST DOUBLE T EACH TIME.
+ */
+ ts3 = t;
+ t = MP_T;
+ do {
+ ts2 = t;
+ t = (t + it0) / 2;
+ } while (t > ts3);
+ t = ts2;
+ }
+
+ /* CHECK THAT NEWTON ITERATION WAS CONVERGING AS EXPECTED */
+ if (t3.sign != 0 && t3.exponent << 1 > it0 - MP_T) {
+ mperr("*** ERROR OCCURRED IN MP_LNS, NEWTON ITERATION NOT CONVERGING PROPERLY ***");
+ }
+
+ z->sign = -z->sign;
+}
+
+
+static void
+mp_ln_real(const MPNumber *x, MPNumber *z)
+{
+ int e, k;
+ float rx, rlx;
+ MPNumber t1, t2;
+
+ /* LOOP TO GET APPROXIMATE LN(X) USING SINGLE-PRECISION */
+ mp_set_from_mp(x, &t1);
+ mp_set_from_integer(0, z);
+ for(k = 0; k < 10; k++)
+ {
+ /* COMPUTE FINAL CORRECTION ACCURATELY USING MP_LNS */
+ mp_add_integer(&t1, -1, &t2);
+ if (mp_is_zero(&t2) || t2.exponent + 1 <= 0) {
+ mp_lns(&t2, &t2);
+ mp_add(z, &t2, z);
+ return;
+ }
+
+ /* REMOVE EXPONENT TO AVOID FLOATING-POINT OVERFLOW */
+ e = t1.exponent;
+ t1.exponent = 0;
+ rx = mp_cast_to_float(&t1);
+ t1.exponent = e;
+ rlx = log(rx) + (float)e * log((float)MP_BASE);
+ mp_set_from_float(-(double)rlx, &t2);
+
+ /* UPDATE Z AND COMPUTE ACCURATE EXP OF APPROXIMATE LOG */
+ mp_subtract(z, &t2, z);
+ mp_epowy(&t2, &t2);
+
+ /* COMPUTE RESIDUAL WHOSE LOG IS STILL TO BE FOUND */
+ mp_multiply(&t1, &t2, &t1);
+ }
+
+ mperr("*** ERROR IN MP_LN, ITERATION NOT CONVERGING ***");
+}
+
+
+void
+mp_ln(const MPNumber *x, MPNumber *z)
+{
+ /* ln(0) undefined */
+ if (mp_is_zero(x)) {
+ /* Translators: Error displayed when attempting to take logarithm of zero */
+ mperr(_("Logarithm of zero is undefined"));
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* ln(-x) complex */
+ /* FIXME: Make complex numbers optional */
+ /*if (mp_is_negative(x)) {
+ // Translators: Error displayed attempted to take logarithm of negative value
+ mperr(_("Logarithm of negative values is undefined"));
+ mp_set_from_integer(0, z);
+ return;
+ }*/
+
+ if (mp_is_complex(x) || mp_is_negative(x)) {
+ MPNumber r, theta, z_real;
+
+ /* ln(re^iθ) = e^(ln(r)+iθ) */
+ mp_abs(x, &r);
+ mp_arg(x, MP_RADIANS, &theta);
+
+ mp_ln_real(&r, &z_real);
+ mp_set_from_complex(&z_real, &theta, z);
+ }
+ else
+ mp_ln_real(x, z);
+}
+
+
+void
+mp_logarithm(int64_t n, const MPNumber *x, MPNumber *z)
+{
+ MPNumber t1, t2;
+ 
+ /* log(0) undefined */
+ if (mp_is_zero(x)) {
+ /* Translators: Error displayed when attempting to take logarithm of zero */
+ mperr(_("Logarithm of zero is undefined"));
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* logn(x) = ln(x) / ln(n) */
+ mp_set_from_integer(n, &t1);
+ mp_ln(&t1, &t1);
+ mp_ln(x, &t2);
+ mp_divide(&t2, &t1, z);
+}
+
+
+bool
+mp_is_less_than(const MPNumber *x, const MPNumber *y)
+{
+ return mp_compare_mp_to_mp(x, y) < 0;
+}
+
+
+static void
+mp_multiply_real(const MPNumber *x, const MPNumber *y, MPNumber *z)
+{
+ int c, i, xi;
+ MPNumber r;
+
+ /* x*0 = 0*y = 0 */ 
+ if (x->sign == 0 || y->sign == 0) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ z->sign = x->sign * y->sign;
+ z->exponent = x->exponent + y->exponent;
+ memset(&r, 0, sizeof(MPNumber));
+
+ /* PERFORM MULTIPLICATION */
+ c = 8;
+ for (i = 0; i < MP_T; i++) {
+ int j;
+
+ xi = x->fraction[i];
+
+ /* FOR SPEED, PUT THE NUMBER WITH MANY ZEROS FIRST */
+ if (xi == 0)
+ continue;
+
+ /* Computing MIN */
+ for (j = 0; j < min(MP_T, MP_T + 3 - i); j++)
+ r.fraction[i+j+1] += xi * y->fraction[j];
+ c--;
+ if (c > 0)
+ continue;
+
+ /* CHECK FOR LEGAL BASE B DIGIT */
+ if (xi < 0 || xi >= MP_BASE) {
+ mperr("*** ILLEGAL BASE B DIGIT IN CALL TO MP_MULTIPLY, POSSIBLE OVERWRITING PROBLEM ***");
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* PROPAGATE CARRIES AT END AND EVERY EIGHTH TIME,
+ * FASTER THAN DOING IT EVERY TIME.
+ */
+ for (j = MP_T + 3; j >= 0; j--) {
+ int ri = r.fraction[j] + c;
+ if (ri < 0) {
+ mperr("*** INTEGER OVERFLOW IN MP_MULTIPLY, B TOO LARGE ***");
+ mp_set_from_integer(0, z);
+ return;
+ }
+ c = ri / MP_BASE;
+ r.fraction[j] = ri - MP_BASE * c;
+ }
+ if (c != 0) {
+ mperr("*** ILLEGAL BASE B DIGIT IN CALL TO MP_MULTIPLY, POSSIBLE OVERWRITING PROBLEM ***");
+ mp_set_from_integer(0, z);
+ return;
+ }
+ c = 8;
+ }
+
+ if (c != 8) {
+ if (xi < 0 || xi >= MP_BASE) {
+ mperr("*** ILLEGAL BASE B DIGIT IN CALL TO MP_MULTIPLY, POSSIBLE OVERWRITING PROBLEM ***");
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ c = 0;
+ for (i = MP_T + 3; i >= 0; i--) {
+ int ri = r.fraction[i] + c;
+ if (ri < 0) {
+ mperr("*** INTEGER OVERFLOW IN MP_MULTIPLY, B TOO LARGE ***");
+ mp_set_from_integer(0, z);
+ return;
+ }
+ c = ri / MP_BASE;
+ r.fraction[i] = ri - MP_BASE * c;
+ }
+
+ if (c != 0) {
+ mperr("*** ILLEGAL BASE B DIGIT IN CALL TO MP_MULTIPLY, POSSIBLE OVERWRITING PROBLEM ***");
+ mp_set_from_integer(0, z);
+ return;
+ }
+ }
+
+ /* Clear complex part */
+ z->im_sign = 0;
+ z->im_exponent = 0;
+ memset(z->im_fraction, 0, sizeof(int) * MP_SIZE); 
+
+ /* NORMALIZE AND ROUND RESULT */
+ // FIXME: Use stack variable because of mp_normalize brokeness
+ for (i = 0; i < MP_SIZE; i++)
+ z->fraction[i] = r.fraction[i];
+ mp_normalize(z);
+}
+
+
+void
+mp_multiply(const MPNumber *x, const MPNumber *y, MPNumber *z)
+{
+ /* x*0 = 0*y = 0 */
+ if (mp_is_zero(x) || mp_is_zero(y)) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* (a+bi)(c+di) = (ac-bd)+(ad+bc)i */
+ if (mp_is_complex(x) || mp_is_complex(y)) {
+ MPNumber real_x, real_y, im_x, im_y, t1, t2, real_z, im_z;
+
+ mp_real_component(x, &real_x);
+ mp_imaginary_component(x, &im_x);
+ mp_real_component(y, &real_y);
+ mp_imaginary_component(y, &im_y);
+ 
+ mp_multiply_real(&real_x, &real_y, &t1);
+ mp_multiply_real(&im_x, &im_y, &t2);
+ mp_subtract(&t1, &t2, &real_z);
+ 
+ mp_multiply_real(&real_x, &im_y, &t1);
+ mp_multiply_real(&im_x, &real_y, &t2);
+ mp_add(&t1, &t2, &im_z);
+
+ mp_set_from_complex(&real_z, &im_z, z);
+ }
+ else {
+ mp_multiply_real(x, y, z);
+ }
+}
+
+
+static void
+mp_multiply_integer_real(const MPNumber *x, int64_t y, MPNumber *z)
+{
+ int c, i;
+ MPNumber x_copy;
+
+ /* x*0 = 0*y = 0 */
+ if (mp_is_zero(x) || y == 0) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* x*1 = x, x*-1 = -x */
+ // FIXME: Why is this not working? mp_ext is using this function to do a normalization
+ /*if (y == 1 || y == -1) {
+ if (y < 0)
+ mp_invert_sign(x, z);
+ else
+ mp_set_from_mp(x, z);
+ return;
+ }*/
+
+ /* Copy x as z may also refer to x */
+ mp_set_from_mp(x, &x_copy);
+ mp_set_from_integer(0, z);
+
+ if (y < 0) {
+ y = -y;
+ z->sign = -x_copy.sign;
+ }
+ else
+ z->sign = x_copy.sign;
+ z->exponent = x_copy.exponent + 4;
+
+ /* FORM PRODUCT IN ACCUMULATOR */
+ c = 0;
+
+ /* IF y*B NOT REPRESENTABLE AS AN INTEGER WE HAVE TO SIMULATE
+ * DOUBLE-PRECISION MULTIPLICATION.
+ */
+
+ /* Computing MAX */
+ if (y >= max(MP_BASE << 3, 32767 / MP_BASE)) {
+ int64_t j1, j2;
+
+ /* HERE J IS TOO LARGE FOR SINGLE-PRECISION MULTIPLICATION */
+ j1 = y / MP_BASE;
+ j2 = y - j1 * MP_BASE;
+
+ /* FORM PRODUCT */
+ for (i = MP_T + 3; i >= 0; i--) {
+ int64_t c1, c2, is, ix, t;
+
+ c1 = c / MP_BASE;
+ c2 = c - MP_BASE * c1;
+ ix = 0;
+ if (i > 3)
+ ix = x_copy.fraction[i - 4];
+
+ t = j2 * ix + c2;
+ is = t / MP_BASE;
+ c = j1 * ix + c1 + is;
+ z->fraction[i] = t - MP_BASE * is;
+ }
+ }
+ else
+ {
+ int64_t ri = 0;
+
+ for (i = MP_T + 3; i >= 4; i--) {
+ ri = y * x_copy.fraction[i - 4] + c;
+ c = ri / MP_BASE;
+ z->fraction[i] = ri - MP_BASE * c;
+ }
+
+ /* CHECK FOR INTEGER OVERFLOW */
+ if (ri < 0) {
+ mperr("*** INTEGER OVERFLOW IN mp_multiply_integer, B TOO LARGE ***");
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* HAVE TO TREAT FIRST FOUR WORDS OF R SEPARATELY */
+ for (i = 3; i >= 0; i--) {
+ int t;
+
+ t = c;
+ c = t / MP_BASE;
+ z->fraction[i] = t - MP_BASE * c;
+ }
+ }
+
+ /* HAVE TO SHIFT RIGHT HERE AS CARRY OFF END */
+ while (c != 0) {
+ int64_t t;
+
+ for (i = MP_T + 3; i >= 1; i--)
+ z->fraction[i] = z->fraction[i - 1];
+ t = c;
+ c = t / MP_BASE;
+ z->fraction[0] = t - MP_BASE * c;
+ z->exponent++;
+ }
+
+ if (c < 0) {
+ mperr("*** INTEGER OVERFLOW IN mp_multiply_integer, B TOO LARGE ***");
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ z->im_sign = 0;
+ z->im_exponent = 0;
+ memset(z->im_fraction, 0, sizeof(int) * MP_SIZE); 
+ mp_normalize(z);
+}
+
+
+void
+mp_multiply_integer(const MPNumber *x, int64_t y, MPNumber *z)
+{
+ if (mp_is_complex(x)) {
+ MPNumber re_z, im_z;
+ mp_real_component(x, &re_z);
+ mp_imaginary_component(x, &im_z);
+ mp_multiply_integer_real(&re_z, y, &re_z);
+ mp_multiply_integer_real(&im_z, y, &im_z);
+ mp_set_from_complex(&re_z, &im_z, z);
+ }
+ else
+ mp_multiply_integer_real(x, y, z);
+}
+
+
+void
+mp_multiply_fraction(const MPNumber *x, int64_t numerator, int64_t denominator, MPNumber *z)
+{
+ if (denominator == 0) {
+ mperr(_("Division by zero is undefined"));
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ if (numerator == 0) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* Reduce to lowest terms */
+ mp_gcd(&numerator, &denominator);
+ mp_divide_integer(x, denominator, z);
+ mp_multiply_integer(z, numerator, z);
+}
+
+
+void
+mp_invert_sign(const MPNumber *x, MPNumber *z)
+{
+ mp_set_from_mp(x, z);
+ z->sign = -z->sign;
+ z->im_sign = -z->im_sign;
+}
+
+
+// FIXME: Is r->fraction large enough? It seems to be in practise but it may be MP_T+4 instead of MP_T
+// FIXME: There is some sort of stack corruption/use of unitialised variables here. Some functions are
+// using stack variables as x otherwise there are corruption errors. e.g. "Cos(45) - 1/Sqrt(2) = -0"
+// (try in scientific mode)
+void
+mp_normalize(MPNumber *x)
+{
+ int start_index;
+
+ /* Find first non-zero digit */
+ for (start_index = 0; start_index < MP_SIZE && x->fraction[start_index] == 0; start_index++);
+
+ /* Mark as zero */
+ if (start_index >= MP_SIZE) {
+ x->sign = 0;
+ x->exponent = 0;
+ return;
+ }
+
+ /* Shift left so first digit is non-zero */
+ if (start_index > 0) {
+ int i;
+
+ x->exponent -= start_index;
+ for (i = 0; (i + start_index) < MP_SIZE; i++)
+ x->fraction[i] = x->fraction[i + start_index];
+ for (; i < MP_SIZE; i++)
+ x->fraction[i] = 0;
+ }
+}
+
+
+static void
+mp_pwr(const MPNumber *x, const MPNumber *y, MPNumber *z)
+{
+ MPNumber t;
+
+ /* (-x)^y imaginary */
+ /* FIXME: Make complex numbers optional */
+ /*if (x->sign < 0) {
+ mperr(_("The power of negative numbers is only defined for integer exponents"));
+ mp_set_from_integer(0, z);
+ return;
+ }*/
+
+ /* 0^-y illegal */
+ if (mp_is_zero(x) && y->sign < 0) {
+ mperr(_("The power of zero is undefined for a negative exponent"));
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* x^0 = 1 */
+ if (mp_is_zero(y)) {
+ mp_set_from_integer(1, z);
+ return;
+ }
+
+ mp_ln(x, &t);
+ mp_multiply(y, &t, z);
+ mp_epowy(z, z);
+}
+
+
+static void
+mp_reciprocal_real(const MPNumber *x, MPNumber *z)
+{
+ MPNumber t1, t2;
+ int it0, t;
+
+ /* 1/0 invalid */
+ if (mp_is_zero(x)) {
+ mperr(_("Reciprocal of zero is undefined"));
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* Start by approximating value using floating point */
+ mp_set_from_mp(x, &t1);
+ t1.exponent = 0;
+ mp_set_from_float(1.0f / mp_cast_to_float(&t1), &t1);
+ t1.exponent -= x->exponent;
+
+ it0 = t = 3;
+ while(1) {
+ int ts2, ts3;
+
+ /* t1 = t1 - (t1 * ((x * t1) - 1)) (2*t1 - t1^2*x) */
+ mp_multiply(x, &t1, &t2);
+ mp_add_integer(&t2, -1, &t2);
+ mp_multiply(&t1, &t2, &t2);
+ mp_subtract(&t1, &t2, &t1);
+ if (t >= MP_T)
+ break;
+
+ /* FOLLOWING LOOP ALMOST DOUBLES T (POSSIBLE
+ * BECAUSE NEWTONS METHOD HAS 2ND ORDER CONVERGENCE).
+ */
+ ts3 = t;
+ t = MP_T;
+ do {
+ ts2 = t;
+ t = (t + it0) / 2;
+ } while (t > ts3);
+ t = min(ts2, MP_T);
+ }
+
+ /* RETURN IF NEWTON ITERATION WAS CONVERGING */
+ if (t2.sign != 0 && (t1.exponent - t2.exponent) << 1 < MP_T - it0) {
+ /* THE FOLLOWING MESSAGE MAY INDICATE THAT B**(T-1) IS TOO SMALL,
+ * OR THAT THE STARTING APPROXIMATION IS NOT ACCURATE ENOUGH.
+ */
+ mperr("*** ERROR OCCURRED IN MP_RECIPROCAL, NEWTON ITERATION NOT CONVERGING PROPERLY ***");
+ }
+
+ mp_set_from_mp(&t1, z);
+}
+
+
+void
+mp_reciprocal(const MPNumber *x, MPNumber *z)
+{ 
+ if (mp_is_complex(x)) {
+ MPNumber t1, t2;
+ MPNumber real_x, im_x;
+
+ mp_real_component(x, &real_x);
+ mp_imaginary_component(x, &im_x);
+
+ /* 1/(a+bi) = (a-bi)/(a+bi)(a-bi) = (a-bi)/(a²+b²) */
+ mp_multiply(&real_x, &real_x, &t1);
+ mp_multiply(&im_x, &im_x, &t2);
+ mp_add(&t1, &t2, &t1);
+ mp_reciprocal_real(&t1, z);
+ mp_conjugate(x, &t1);
+ mp_multiply(&t1, z, z);
+ }
+ else
+ mp_reciprocal_real(x, z);
+}
+
+
+static void
+mp_root_real(const MPNumber *x, int64_t n, MPNumber *z)
+{
+ float approximation;
+ int ex, np, it0, t;
+ MPNumber t1, t2;
+
+ /* x^(1/1) = x */
+ if (n == 1) {
+ mp_set_from_mp(x, z);
+ return;
+ }
+
+ /* x^(1/0) invalid */
+ if (n == 0) {
+ mperr(_("Root must be non-zero"));
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ np = abs(n);
+
+ /* LOSS OF ACCURACY IF NP LARGE, SO ONLY ALLOW NP <= MAX (B, 64) */
+ if (np > max(MP_BASE, 64)) {
+ mperr("*** ABS(N) TOO LARGE IN CALL TO MP_ROOT ***");
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* 0^(1/n) = 0 for positive n */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(0, z);
+ if (n <= 0)
+ mperr(_("Negative root of zero is undefined"));
+ return;
+ }
+
+ // FIXME: Imaginary root
+ if (x->sign < 0 && np % 2 == 0) {
+ mperr(_("nth root of negative number is undefined for even n"));
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* DIVIDE EXPONENT BY NP */
+ ex = x->exponent / np;
+
+ /* Get initial approximation */
+ mp_set_from_mp(x, &t1);
+ t1.exponent = 0;
+ approximation = exp(((float)(np * ex - x->exponent) * log((float)MP_BASE) -
+ log((fabs(mp_cast_to_float(&t1))))) / (float)np);
+ mp_set_from_float(approximation, &t1);
+ t1.sign = x->sign;
+ t1.exponent -= ex;
+
+ /* MAIN ITERATION LOOP */
+ it0 = t = 3;
+ while(1) {
+ int ts2, ts3;
+
+ /* t1 = t1 - ((t1 * ((x * t1^np) - 1)) / np) */
+ mp_xpowy_integer(&t1, np, &t2);
+ mp_multiply(x, &t2, &t2);
+ mp_add_integer(&t2, -1, &t2);
+ mp_multiply(&t1, &t2, &t2);
+ mp_divide_integer(&t2, np, &t2);
+ mp_subtract(&t1, &t2, &t1);
+
+ /* FOLLOWING LOOP ALMOST DOUBLES T (POSSIBLE BECAUSE
+ * NEWTONS METHOD HAS 2ND ORDER CONVERGENCE).
+ */
+ if (t >= MP_T)
+ break;
+
+ ts3 = t;
+ t = MP_T;
+ do {
+ ts2 = t;
+ t = (t + it0) / 2;
+ } while (t > ts3);
+ t = min(ts2, MP_T);
+ }
+
+ /* NOW R(I2) IS X**(-1/NP)
+ * CHECK THAT NEWTON ITERATION WAS CONVERGING
+ */
+ if (t2.sign != 0 && (t1.exponent - t2.exponent) << 1 < MP_T - it0) {
+ /* THE FOLLOWING MESSAGE MAY INDICATE THAT B**(T-1) IS TOO SMALL,
+ * OR THAT THE INITIAL APPROXIMATION OBTAINED USING ALOG AND EXP
+ * IS NOT ACCURATE ENOUGH.
+ */
+ mperr("*** ERROR OCCURRED IN MP_ROOT, NEWTON ITERATION NOT CONVERGING PROPERLY ***");
+ }
+
+ if (n >= 0) {
+ mp_xpowy_integer(&t1, n - 1, &t1);
+ mp_multiply(x, &t1, z);
+ return;
+ }
+
+ mp_set_from_mp(&t1, z);
+}
+
+
+void
+mp_root(const MPNumber *x, int64_t n, MPNumber *z)
+{
+ if (!mp_is_complex(x) && mp_is_negative(x) && n % 2 == 1) {
+ mp_abs(x, z);
+ mp_root_real(z, n, z);
+ mp_invert_sign(z, z);
+ }
+ else if (mp_is_complex(x) || mp_is_negative(x)) {
+ MPNumber r, theta;
+
+ mp_abs(x, &r);
+ mp_arg(x, MP_RADIANS, &theta);
+
+ mp_root_real(&r, n, &r);
+ mp_divide_integer(&theta, n, &theta);
+ mp_set_from_polar(&r, MP_RADIANS, &theta, z);
+ }
+ else
+ mp_root_real(x, n, z);
+}
+
+
+void
+mp_sqrt(const MPNumber *x, MPNumber *z)
+{
+ if (mp_is_zero(x))
+ mp_set_from_integer(0, z);
+ /* FIXME: Make complex numbers optional */
+ /*else if (x->sign < 0) {
+ mperr(_("Square root is undefined for negative values"));
+ mp_set_from_integer(0, z);
+ }*/
+ else {
+ MPNumber t;
+
+ mp_root(x, -2, &t);
+ mp_multiply(x, &t, z);
+ mp_ext(t.fraction[0], z->fraction[0], z);
+ }
+}
+
+
+void
+mp_factorial(const MPNumber *x, MPNumber *z)
+{
+ int i, value;
+
+ /* 0! == 1 */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(1, z);
+ return;
+ }
+ if (!mp_is_natural(x)) {
+ /* Translators: Error displayed when attempted take the factorial of a fractional number */
+ mperr(_("Factorial is only defined for natural numbers"));
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* Convert to integer - if couldn't be converted then the factorial would be too big anyway */
+ value = mp_cast_to_int(x);
+ mp_set_from_mp(x, z);
+ for (i = 2; i < value; i++)
+ mp_multiply_integer(z, i, z);
+}
+
+
+void
+mp_modulus_divide(const MPNumber *x, const MPNumber *y, MPNumber *z)
+{
+ MPNumber t1, t2;
+
+ if (!mp_is_integer(x) || !mp_is_integer(y)) {
+ /* Translators: Error displayed when attemping to do a modulus division on non-integer numbers */
+ mperr(_("Modulus division is only defined for integers"));
+ mp_set_from_integer(0, z);
+ }
+
+ mp_divide(x, y, &t1);
+ mp_floor(&t1, &t1);
+ mp_multiply(&t1, y, &t2);
+ mp_subtract(x, &t2, z);
+
+ mp_set_from_integer(0, &t1);
+ if ((mp_is_less_than(y, &t1) && mp_is_greater_than(z, &t1)) || mp_is_less_than(z, &t1))
+ mp_add(z, y, z);
+}
+
+
+void
+mp_xpowy(const MPNumber *x, const MPNumber *y, MPNumber *z)
+{
+ if (mp_is_integer(y)) {
+ mp_xpowy_integer(x, mp_cast_to_int(y), z);
+ } else {
+ MPNumber reciprocal;
+ mp_reciprocal(y, &reciprocal);
+ if (mp_is_integer(&reciprocal))
+ mp_root(x, mp_cast_to_int(&reciprocal), z);
+ else
+ mp_pwr(x, y, z);
+ }
+}
+
+
+void
+mp_xpowy_integer(const MPNumber *x, int64_t n, MPNumber *z)
+{
+ int i;
+ MPNumber t;
+
+ /* 0^-n invalid */
+ if (mp_is_zero(x) && n < 0) {
+ /* Translators: Error displayed when attempted to raise 0 to a negative exponent */
+ mperr(_("The power of zero is undefined for a negative exponent"));
+ mp_set_from_integer(0, z);
+ return;
+ }
+
+ /* x^0 = 1 */
+ if (n == 0) {
+ mp_set_from_integer(1, z);
+ return;
+ }
+
+ /* 0^n = 0 */
+ if (mp_is_zero(x)) {
+ mp_set_from_integer(0, z);
+ return;
+ }
+ 
+ /* x^1 = x */
+ if (n == 1) {
+ mp_set_from_mp(x, z);
+ return;
+ }
+
+ if (n < 0) {
+ mp_reciprocal(x, &t);
+ n = -n;
+ }
+ else
+ mp_set_from_mp(x, &t);
+
+ /* Multply x n times */
+ // FIXME: Can do mp_multiply(z, z, z) until close to answer (each call doubles number of multiples) */
+ mp_set_from_integer(1, z);
+ for (i = 0; i < n; i++)
+ mp_multiply(z, &t, z);
+}
+
+
+GList*
+mp_factorize(const MPNumber *x)
+{
+ GList *list = NULL;
+ MPNumber *factor = g_slice_alloc0(sizeof(MPNumber));
+ MPNumber value, tmp, divisor, root;
+
+ mp_abs(x, &value);
+
+ if (mp_is_zero(&value)) {
+ mp_set_from_mp(&value, factor);
+ list = g_list_append(list, factor);
+ return list;
+ }
+
+ mp_set_from_integer(1, &tmp);
+ if (mp_is_equal(&value, &tmp)) {
+ mp_set_from_mp(x, factor);
+ list = g_list_append(list, factor);
+ return list;
+ }
+
+ mp_set_from_integer(2, &divisor);
+ while (TRUE) {
+ mp_divide(&value, &divisor, &tmp);
+ if (mp_is_integer(&tmp)) {
+ value = tmp;
+ mp_set_from_mp(&divisor, factor);
+ list = g_list_append(list, factor);
+ factor = g_slice_alloc0(sizeof(MPNumber));
+ } else {
+ break;
+ }
+ }
+
+ mp_set_from_integer(3, &divisor);
+ mp_sqrt(&value, &root);
+ while (mp_is_less_equal(&divisor, &root)) {
+ mp_divide(&value, &divisor, &tmp);
+ if (mp_is_integer(&tmp)) {
+ value = tmp;
+ mp_sqrt(&value, &root);
+ mp_set_from_mp(&divisor, factor);
+ list = g_list_append(list, factor);
+ factor = g_slice_alloc0(sizeof(MPNumber));
+ } else {
+ mp_add_integer(&divisor, 2, &tmp);
+ divisor = tmp;
+ }
+ }
+
+ mp_set_from_integer(1, &tmp);
+ if (mp_is_greater_than(&value, &tmp)) {
+ mp_set_from_mp(&value, factor);
+ list = g_list_append(list, factor);
+ } else {
+ g_slice_free(MPNumber, factor);
+ }
+
+ if (mp_is_negative(x)) {
+ mp_invert_sign(list->data, list->data);
+ }
+
+ return list;
+}
diff --git a/src/mp.h b/src/mp.h
new file mode 100644
index 0000000..d71111d
--- /dev/null
+++ b/src/mp.h
@@ -0,0 +1,357 @@
+
+/* Copyright (c) 1987-2008 Sun Microsystems, Inc. All Rights Reserved.
+ * Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+/* This maths library is based on the MP multi-precision floating-point
+ * arithmetic package originally written in FORTRAN by Richard Brent,
+ * Computer Centre, Australian National University in the 1970's.
+ *
+ * It has been converted from FORTRAN into C using the freely available
+ * f2c translator, available via netlib on research.att.com.
+ *
+ * The subsequently converted C code has then been tidied up, mainly to
+ * remove any dependencies on the libI77 and libF77 support libraries.
+ *
+ * FOR A GENERAL DESCRIPTION OF THE PHILOSOPHY AND DESIGN OF MP,
+ * SEE - R. P. BRENT, A FORTRAN MULTIPLE-PRECISION ARITHMETIC
+ * PACKAGE, ACM TRANS. MATH. SOFTWARE 4 (MARCH 1978), 57-70.
+ * SOME ADDITIONAL DETAILS ARE GIVEN IN THE SAME ISSUE, 71-81.
+ * FOR DETAILS OF THE IMPLEMENTATION, CALLING SEQUENCES ETC. SEE
+ * THE MP USERS GUIDE.
+ */
+
+#ifndef MP_H
+#define MP_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <glib.h>
+
+/* Size of the multiple precision values */
+#define MP_SIZE 1000
+
+/* Base for numbers */
+#define MP_BASE 10000
+
+/* Object for a high precision floating point number representation
+ *
+ * x = sign * (MP_BASE^(exponent-1) + MP_BASE^(exponent-2) + ...)
+ */
+typedef struct
+{
+ /* Sign (+1, -1) or 0 for the value zero */
+ int sign, im_sign;
+
+ /* Exponent (to base MP_BASE) */
+ int exponent, im_exponent;
+
+ /* Normalized fraction */
+ int fraction[MP_SIZE], im_fraction[MP_SIZE];
+} MPNumber;
+
+typedef enum
+{
+ MP_RADIANS,
+ MP_DEGREES,
+ MP_GRADIANS
+} MPAngleUnit;
+
+/* Returns error string or NULL if no error */
+// FIXME: Global variable
+const char *mp_get_error(void);
+
+/* Clear any current error */
+void mp_clear_error(void);
+
+/* Returns:
+ * 0 if x == y
+ * <0 if x < y
+ * >0 if x > y
+ */
+int mp_compare_mp_to_mp(const MPNumber *x, const MPNumber *y);
+
+/* Return true if the value is x == 0 */
+bool mp_is_zero(const MPNumber *x);
+
+/* Return true if x < 0 */
+bool mp_is_negative(const MPNumber *x);
+
+/* Return true if x is integer */
+bool mp_is_integer(const MPNumber *x);
+
+/* Return true if x is a positive integer */
+bool mp_is_positive_integer(const MPNumber *x);
+
+/* Return true if x is a natural number (an integer ≥ 0) */
+bool mp_is_natural(const MPNumber *x);
+
+/* Return true if x has an imaginary component */
+bool mp_is_complex(const MPNumber *x);
+
+/* Return true if x == y */
+bool mp_is_equal(const MPNumber *x, const MPNumber *y);
+
+/* Return true if x ≥ y */
+bool mp_is_greater_equal(const MPNumber *x, const MPNumber *y);
+
+/* Return true if x > y */
+bool mp_is_greater_than(const MPNumber *x, const MPNumber *y);
+
+/* Return true if x ≤ y */
+bool mp_is_less_equal(const MPNumber *x, const MPNumber *y);
+
+/* Return true if x < y */
+bool mp_is_less_than(const MPNumber *x, const MPNumber *y);
+
+/* Sets z = |x| */
+void mp_abs(const MPNumber *x, MPNumber *z);
+
+/* Sets z = Arg(x) */
+void mp_arg(const MPNumber *x, MPAngleUnit unit, MPNumber *z);
+
+/* Sets z = ‾̅x */
+void mp_conjugate(const MPNumber *x, MPNumber *z);
+
+/* Sets z = Re(x) */
+void mp_real_component(const MPNumber *x, MPNumber *z);
+
+/* Sets z = Im(x) */
+void mp_imaginary_component(const MPNumber *x, MPNumber *z);
+
+/* Sets z = −x */
+void mp_invert_sign(const MPNumber *x, MPNumber *z);
+
+/* Sets z = x + y */
+void mp_add(const MPNumber *x, const MPNumber *y, MPNumber *z);
+
+/* Sets z = x + y */
+void mp_add_integer(const MPNumber *x, int64_t y, MPNumber *z);
+
+/* Sets z = x + numerator ÷ denominator */
+void mp_add_fraction(const MPNumber *x, int64_t numerator, int64_t denominator, MPNumber *z);
+
+/* Sets z = x − y */
+void mp_subtract(const MPNumber *x, const MPNumber *y, MPNumber *z);
+
+/* Sets z = x × y */
+void mp_multiply(const MPNumber *x, const MPNumber *y, MPNumber *z);
+
+/* Sets z = x × y */
+void mp_multiply_integer(const MPNumber *x, int64_t y, MPNumber *z);
+
+/* Sets z = x × numerator ÷ denominator */
+void mp_multiply_fraction(const MPNumber *x, int64_t numerator, int64_t denominator, MPNumber *z);
+
+/* Sets z = x ÷ y */
+void mp_divide(const MPNumber *x, const MPNumber *y, MPNumber *z);
+
+/* Sets z = x ÷ y */
+void mp_divide_integer(const MPNumber *x, int64_t y, MPNumber *z);
+
+/* Sets z = 1 ÷ x */
+void mp_reciprocal(const MPNumber *, MPNumber *);
+
+/* Sets z = sgn(x) */
+void mp_sgn(const MPNumber *x, MPNumber *z);
+
+void mp_integer_component(const MPNumber *x, MPNumber *z);
+
+/* Sets z = x mod 1 */
+void mp_fractional_component(const MPNumber *x, MPNumber *z);
+
+/* Sets z = {x} */
+void mp_fractional_part(const MPNumber *x, MPNumber *z);
+
+/* Sets z = ⌊x⌋ */
+void mp_floor(const MPNumber *x, MPNumber *z);
+
+/* Sets z = ⌈x⌉ */
+void mp_ceiling(const MPNumber *x, MPNumber *z);
+
+/* Sets z = [x] */
+void mp_round(const MPNumber *x, MPNumber *z);
+
+/* Sets z = ln x */
+void mp_ln(const MPNumber *x, MPNumber *z);
+
+/* Sets z = log_n x */
+void mp_logarithm(int64_t n, const MPNumber *x, MPNumber *z);
+
+/* Sets z = π */
+void mp_get_pi(MPNumber *z);
+
+/* Sets z = e */
+void mp_get_eulers(MPNumber *z);
+
+/* Sets z = i (√−1) */
+void mp_get_i(MPNumber *z);
+
+/* Sets z = n√x */
+void mp_root(const MPNumber *x, int64_t n, MPNumber *z);
+
+/* Sets z = √x */
+void mp_sqrt(const MPNumber *x, MPNumber *z);
+
+/* Sets z = x! */
+void mp_factorial(const MPNumber *x, MPNumber *z);
+
+/* Sets z = x mod y */
+void mp_modulus_divide(const MPNumber *x, const MPNumber *y, MPNumber *z);
+
+/* Sets z = x^y */
+void mp_xpowy(const MPNumber *x, const MPNumber *y, MPNumber *z);
+
+/* Sets z = x^y */
+void mp_xpowy_integer(const MPNumber *x, int64_t y, MPNumber *z);
+
+/* Sets z = e^x */
+void mp_epowy(const MPNumber *x, MPNumber *z);
+
+/* Returns a list of all prime factors in x as MPNumbers */
+GList* mp_factorize(const MPNumber *x);
+
+/* Sets z = x */
+void mp_set_from_mp(const MPNumber *x, MPNumber *z);
+
+/* Sets z = x */
+void mp_set_from_float(float x, MPNumber *z);
+
+/* Sets z = x */
+void mp_set_from_double(double x, MPNumber *z);
+
+/* Sets z = x */
+void mp_set_from_integer(int64_t x, MPNumber *z);
+
+/* Sets z = x */
+void mp_set_from_unsigned_integer(uint64_t x, MPNumber *z);
+
+/* Sets z = numerator ÷ denominator */
+void mp_set_from_fraction(int64_t numerator, int64_t denominator, MPNumber *z);
+
+/* Sets z = r(cos theta + i sin theta) */
+void mp_set_from_polar(const MPNumber *r, MPAngleUnit unit, const MPNumber *theta, MPNumber *z);
+
+/* Sets z = x + iy */
+void mp_set_from_complex(const MPNumber *x, const MPNumber *y, MPNumber *z);
+
+/* Sets z to be a uniform random number in the range [0, 1] */
+void mp_set_from_random(MPNumber *z);
+
+/* Sets z from a string representation in 'text'.
+ * Returns true on success.
+ */
+bool mp_set_from_string(const char *text, int default_base, MPNumber *z);
+
+/* Returns x as a native single-precision floating point number */
+float mp_cast_to_float(const MPNumber *x);
+
+/* Returns x as a native double-precision floating point number */
+double mp_cast_to_double(const MPNumber *x);
+
+/* Returns x as a native integer */
+int64_t mp_cast_to_int(const MPNumber *x);
+
+/* Returns x as a native unsigned integer */
+uint64_t mp_cast_to_unsigned_int(const MPNumber *x);
+
+/* Converts x to a string representation.
+ * The string is written into 'buffer' which is guaranteed to be at least 'buffer_length' octets in size.
+ * If not enough space is available the string is truncated.
+ * The numbers are written in 'base' (e.g. 10).
+ * If 'trim_zeroes' is non-zero then strip off trailing zeroes.
+ * Fractional components are truncated at 'max_digits' digits.
+ */
+void mp_cast_to_string(const MPNumber *x, int default_base, int base, int max_digits, bool trim_zeroes, char *buffer, int buffer_length);
+
+/* Converts x to a string representation in exponential form.
+ * The string is written into 'buffer' which is guaranteed to be at least 'buffer_length' octets in size.
+ * If not enough space is available the string is truncated.
+ * The numbers are written in 'base' (e.g. 10).
+ * If 'trim_zeroes' is non-zero then strip off trailing zeroes.
+ * Fractional components are truncated at 'max_digits' digits.
+ */
+void mp_cast_to_exponential_string(const MPNumber *x, int default_base, int base, int max_digits, bool trim_zeroes, bool eng_format, char *buffer, int buffer_length);
+
+/* Sets z = sin x */
+void mp_sin(const MPNumber *x, MPAngleUnit unit, MPNumber *z);
+
+/* Sets z = cos x */
+void mp_cos(const MPNumber *x, MPAngleUnit unit, MPNumber *z);
+
+/* Sets z = tan x */
+void mp_tan(const MPNumber *x, MPAngleUnit unit, MPNumber *z);
+
+/* Sets z = sin⁻¹ x */
+void mp_asin(const MPNumber *x, MPAngleUnit unit, MPNumber *z);
+
+/* Sets z = cos⁻¹ x */
+void mp_acos(const MPNumber *x, MPAngleUnit unit, MPNumber *z);
+
+/* Sets z = tan⁻¹ x */
+void mp_atan(const MPNumber *x, MPAngleUnit unit, MPNumber *z);
+
+/* Sets z = sinh x */
+void mp_sinh(const MPNumber *x, MPNumber *z);
+
+/* Sets z = cosh x */
+void mp_cosh(const MPNumber *x, MPNumber *z);
+
+/* Sets z = tanh x */
+void mp_tanh(const MPNumber *x, MPNumber *z);
+
+/* Sets z = sinh⁻¹ x */
+void mp_asinh(const MPNumber *x, MPNumber *z);
+
+/* Sets z = cosh⁻¹ x */
+void mp_acosh(const MPNumber *x, MPNumber *z);
+
+/* Sets z = tanh⁻¹ x */
+void mp_atanh(const MPNumber *x, MPNumber *z);
+
+/* Returns true if x is cannot be represented in a binary word of length 'wordlen' */
+bool mp_is_overflow(const MPNumber *x, int wordlen);
+
+/* Sets z = boolean AND for each bit in x and z */
+void mp_and(const MPNumber *x, const MPNumber *y, MPNumber *z);
+
+/* Sets z = boolean OR for each bit in x and z */
+void mp_or(const MPNumber *x, const MPNumber *y, MPNumber *z);
+
+/* Sets z = boolean XOR for each bit in x and z */
+void mp_xor(const MPNumber *x, const MPNumber *y, MPNumber *z);
+
+/* Sets z = boolean XNOR for each bit in x and z for word of length 'wordlen' */
+void mp_xnor(const MPNumber *x, const MPNumber *y, int wordlen, MPNumber *z);
+
+/* Sets z = boolean NOT for each bit in x and z for word of length 'wordlen' */
+void mp_not(const MPNumber *x, int wordlen, MPNumber *z);
+
+/* Sets z = x masked to 'wordlen' bits */
+void mp_mask(const MPNumber *x, int wordlen, MPNumber *z);
+
+/* Sets z = x shifted by 'count' bits. Positive shift increases the value, negative decreases */
+void mp_shift(const MPNumber *x, int count, MPNumber *z);
+
+/* Sets z to be the ones complement of x for word of length 'wordlen' */
+void mp_ones_complement(const MPNumber *x, int wordlen, MPNumber *z);
+
+/* Sets z to be the twos complement of x for word of length 'wordlen' */
+void mp_twos_complement(const MPNumber *x, int wordlen, MPNumber *z);
+
+#endif /* MP_H */
diff --git a/src/unittest.c b/src/unittest.c
new file mode 100644
index 0000000..791391b
--- /dev/null
+++ b/src/unittest.c
@@ -0,0 +1,761 @@
+/* Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "unittest.h"
+#include "mp-equation.h"
+
+static MPEquationOptions options;
+
+static int fails = 0;
+
+/* If we're not using GNU C, elide __attribute__ */
+#ifndef __GNUC__
+# define __attribute__(x) /*NOTHING*/
+#endif
+
+static void pass(const char *format, ...) __attribute__((format(printf, 1, 2)));
+static void fail(const char *format, ...) __attribute__((format(printf, 1, 2)));
+
+static void pass(const char *format, ...)
+{
+ va_list args;
+
+ printf(" PASS: ");
+ va_start(args, format);
+ vprintf(format, args);
+ va_end(args);
+ printf("\n");
+}
+
+static void fail(const char *format, ...)
+{
+ va_list args;
+
+ printf("*FAIL: ");
+ va_start(args, format);
+ vprintf(format, args);
+ va_end(args);
+ printf("\n");
+ fails++;
+}
+
+
+static const char *
+error_code_to_string(MPErrorCode error)
+{
+ static char error_string[1024];
+
+ if (error != PARSER_ERR_MP)
+ return mp_error_code_to_string(error);
+
+ snprintf(error_string, 1024, "PARSER_ERR_MP(\"%s\")", mp_get_error());
+ return error_string;
+}
+
+
+static void
+test(char *expression, char *expected, int expected_error)
+{
+ MPErrorCode error;
+ MPNumber result;
+ char result_str[1024] = "";
+
+ error = mp_equation_parse(expression, &options, &result, NULL);
+
+ if(error == 0) {
+ mp_cast_to_string(&result, options.base, options.base, 9, 1, result_str, 1024);
+ if(expected_error != 0)
+ fail("'%s' -> %s, expected error %s", expression, result_str, error_code_to_string(expected_error));
+ else if(strcmp(result_str, expected) != 0)
+ fail("'%s' -> '%s', expected '%s'", expression, result_str, expected);
+ else
+ pass("'%s' -> '%s'", expression, result_str);
+ }
+ else {
+ if(error == expected_error)
+ pass("'%s' -> error %s", expression, error_code_to_string(error));
+ else
+ fail("'%s' -> error %s, expected error %s", expression,
+ error_code_to_string(error), error_code_to_string(expected_error));
+ }
+}
+
+
+static void
+test_conversions()
+{
+ memset(&options, 0, sizeof(options));
+ options.base = 10;
+ options.wordlen = 32;
+ options.angle_units = MP_DEGREES;
+
+ /* Length */
+ test("1 meter in mm", "1000", 0); 
+ test("1m in mm", "1000", 0);
+ test("1 inch in cm", "2.54", 0);
+
+ /* Area */
+ test("1m² in mm²", "1000000", 0);
+ 
+ /* Volume */
+ test("1m³ in mm³", "1000000000", 0); 
+
+ /* Weight */
+ test("1 kg in pounds", "2.204622622", 0);
+ 
+ /* Time */
+ test("1 minute in seconds", "60", 0);
+}
+
+
+static int
+variable_is_defined(const char *name, void *data)
+{
+ return strcmp (name, "x") == 0 || strcmp (name, "y") == 0;
+}
+
+
+static int
+get_variable(const char *name, MPNumber *z, void *data)
+{
+ if (strcmp (name, "x") == 0) {
+ mp_set_from_integer (2, z);
+ return 1;
+ }
+ if (strcmp (name, "y") == 0) {
+ mp_set_from_integer (3, z);
+ return 1;
+ }
+ return 0; 
+}
+
+
+static void
+set_variable(const char *name, const MPNumber *x, void *data)
+{
+}
+
+static void
+test_equations()
+{
+ memset(&options, 0, sizeof(options));
+ options.base = 10;
+ options.wordlen = 32;
+ options.angle_units = MP_DEGREES;
+ options.variable_is_defined = variable_is_defined; 
+ options.get_variable = get_variable;
+ options.set_variable = set_variable;
+
+ options.base = 2;
+ test("2₁₀", "10", 0);
+
+ options.base = 8;
+ test("16434824₁₀", "76543210", 0);
+
+ options.base = 16;
+ test("FF", "FF", 0);
+ test("18364758544493064720₁₀", "FEDCBA9876543210", 0);
+
+ options.base = 10;
+ test("0₂", "0", 0); test("0₈", "0", 0); test("0", "0", 0); test("0₁₆", "0", 0);
+ test("1₂", "1", 0); test("1₈", "1", 0); test("1", "1", 0); test("1₁₆", "1", 0);
+ test("2₂", "", PARSER_ERR_INVALID); test("2₈", "2", 0); test("2", "2", 0); test("2₁₆", "2", 0);
+ test("3₂", "", PARSER_ERR_INVALID); test("3₈", "3", 0); test("3", "3", 0); test("3₁₆", "3", 0);
+ test("4₂", "", PARSER_ERR_INVALID); test("4₈", "4", 0); test("4", "4", 0); test("4₁₆", "4", 0);
+ test("5₂", "", PARSER_ERR_INVALID); test("5₈", "5", 0); test("5", "5", 0); test("5₁₆", "5", 0);
+ test("6₂", "", PARSER_ERR_INVALID); test("6₈", "6", 0); test("6", "6", 0); test("6₁₆", "6", 0);
+ test("7₂", "", PARSER_ERR_INVALID); test("7₈", "7", 0); test("7", "7", 0); test("7₁₆", "7", 0);
+ test("8₂", "", PARSER_ERR_INVALID); test("8₈", "", PARSER_ERR_INVALID); test("8", "8", 0); test("8₁₆", "8", 0);
+ test("9₂", "", PARSER_ERR_INVALID); test("9₈", "", PARSER_ERR_INVALID); test("9", "9", 0); test("9₁₆", "9", 0);
+ test("A₂", "", PARSER_ERR_UNKNOWN_VARIABLE); test("A₈", "", PARSER_ERR_UNKNOWN_VARIABLE); test("A", "", PARSER_ERR_UNKNOWN_VARIABLE); test("A₁₆", "10", 0);
+ test("B₂", "", PARSER_ERR_UNKNOWN_VARIABLE); test("B₈", "", PARSER_ERR_UNKNOWN_VARIABLE); test("B", "", PARSER_ERR_UNKNOWN_VARIABLE); test("B₁₆", "11", 0);
+ test("C₂", "", PARSER_ERR_UNKNOWN_VARIABLE); test("C₈", "", PARSER_ERR_UNKNOWN_VARIABLE); test("C", "", PARSER_ERR_UNKNOWN_VARIABLE); test("C₁₆", "12", 0);
+ test("D₂", "", PARSER_ERR_UNKNOWN_VARIABLE); test("D₈", "", PARSER_ERR_UNKNOWN_VARIABLE); test("D", "", PARSER_ERR_UNKNOWN_VARIABLE); test("D₁₆", "13", 0);
+ test("E₂", "", PARSER_ERR_UNKNOWN_VARIABLE); test("E₈", "", PARSER_ERR_UNKNOWN_VARIABLE); test("E", "", PARSER_ERR_UNKNOWN_VARIABLE); test("E₁₆", "14", 0);
+ test("F₂", "", PARSER_ERR_UNKNOWN_VARIABLE); test("F₈", "", PARSER_ERR_UNKNOWN_VARIABLE); test("F", "", PARSER_ERR_UNKNOWN_VARIABLE); test("F₁₆", "15", 0);
+ test("a₂", "", PARSER_ERR_UNKNOWN_VARIABLE); test("a₈", "", PARSER_ERR_UNKNOWN_VARIABLE); test("a", "", PARSER_ERR_UNKNOWN_VARIABLE); test("a₁₆", "10", 0);
+ test("b₂", "", PARSER_ERR_UNKNOWN_VARIABLE); test("b₈", "", PARSER_ERR_UNKNOWN_VARIABLE); test("b", "", PARSER_ERR_UNKNOWN_VARIABLE); test("b₁₆", "11", 0);
+ test("c₂", "", PARSER_ERR_UNKNOWN_VARIABLE); test("c₈", "", PARSER_ERR_UNKNOWN_VARIABLE); test("c", "", PARSER_ERR_UNKNOWN_VARIABLE); test("c₁₆", "12", 0);
+ test("d₂", "", PARSER_ERR_UNKNOWN_VARIABLE); test("d₈", "", PARSER_ERR_UNKNOWN_VARIABLE); test("d", "", PARSER_ERR_UNKNOWN_VARIABLE); test("d₁₆", "13", 0);
+ test("e₂", "", PARSER_ERR_UNKNOWN_VARIABLE); test("e₈", "", PARSER_ERR_UNKNOWN_VARIABLE); /* e is a built-in variable */ test("e₁₆", "14", 0);
+ test("f₂", "", PARSER_ERR_UNKNOWN_VARIABLE); test("f₈", "", PARSER_ERR_UNKNOWN_VARIABLE); test("f", "", PARSER_ERR_UNKNOWN_VARIABLE); test("f₁₆", "15", 0);
+
+ test("+1", "1", 0);
+ test("−1", "−1", 0);
+ test("+ 1", "1", 0); // FIXME: Should this be allowed?
+ test("− 1", "−1", 0); // FIXME: Should this be allowed?
+ test("++1", "1", PARSER_ERR_INVALID);
+ test("−−1", "1", 0);
+ test("255", "255", 0);
+ test("256", "256", 0);
+ test("½", "0.5", 0);
+ test("1½", "1.5", 0);
+ test("0°", "0", 0);
+ test("1°", "1", 0);
+ test("0°30'", "0.5", 0);
+ //test("0°0.1'", "1", 0); // FIXME: Not yet supported
+ test("0°0'1\"", "0.000277778", 0);
+ test("0°0'0.1\"", "0.000027778", 0);
+ test("1.00", "1", 0);
+ test("1.01", "1.01", 0);
+
+ test("١٢٣٤٥٦٧٨٩٠", "1234567890", 0);
+ test("۱۲۳۴۵۶۷۸۹۰", "1234567890", 0);
+
+/* 
+ //test("2A", "2000000000000000", 0);
+ test("2T", "2000000000000", 0);
+ test("2G", "2000000000", 0);
+ test("2M", "2000000", 0);
+ test("2k", "2000", 0);
+ test("2c", "0.02", 0);
+ test("2d", "0.2", 0);
+ test("2c", "0.02", 0);
+ test("2m", "0.002", 0);
+ test("2u", "0.000002", 0);
+ test("2µ", "0.000002", 0);
+ test("2n", "0.000000002", 0);
+ //test("2p", "0.000000000002", 0); // FIXME: Need to print out significant figures, not decimal places
+ //test("2f", "0.000000000000002", 0); // FIXME: Need to print out significant figures, not decimal places
+ //test("2A3", "2300000000000000", 0);
+ test("2T3", "2300000000000", 0);
+ test("2G3", "2300000000", 0);
+ test("2M3", "2300000", 0);
+ test("2k3", "2300", 0);
+ test("2c3", "0.023", 0);
+ test("2d3", "0.23", 0);
+ test("2c3", "0.023", 0);
+ test("2m3", "0.0023", 0);
+ test("2u3", "0.0000023", 0);
+ test("2µ3", "0.0000023", 0);
+ //test("2n3", "0.0000000023", 0); // FIXME: Need to print out significant figures, not decimal places
+ //test("2p3", "0.0000000000023", 0); // FIXME: Need to print out significant figures, not decimal places
+ //test("2f3", "0.0000000000000023", 0); // FIXME: Need to print out significant figures, not decimal places
+*/
+
+ test("2×10^3", "2000", 0);
+ test("2×10^−3", "0.002", 0);
+
+ test("x", "2", 0);
+ test("y", "3", 0);
+ test("z", "", PARSER_ERR_UNKNOWN_VARIABLE);
+ test("2y", "6", 0);
+ test("y2", "", PARSER_ERR_INVALID);
+ test("y 2", "", PARSER_ERR_INVALID);
+ test("2z", "", PARSER_ERR_UNKNOWN_VARIABLE); 
+ test("z2", "", PARSER_ERR_UNKNOWN_VARIABLE);
+ test("z 2", "", PARSER_ERR_UNKNOWN_VARIABLE);
+ test("z(2)", "", PARSER_ERR_UNKNOWN_VARIABLE);
+ test("y²", "9", 0);
+ test("2y²", "18", 0);
+ test("x×y", "6", 0);
+ test("xy", "6", 0);
+ test("yx", "6", 0);
+ test("2xy", "12", 0);
+ test("x²y", "12", 0);
+ test("xy²", "18", 0);
+ test("(xy)²", "36", 0);
+ test("2x²y", "24", 0);
+ test("2xy²", "36", 0);
+ test("2x²y²", "72", 0);
+ test("x²yx²y", "144", 0);
+ test("x³+2x²−5", "11", 0);
+ test("2(x+3y)", "22", 0);
+ test("x(x+3y)", "22", 0);
+ test("(x+3y)(2x-4y)", "−88", 0);
+ test("2x²+2xy−12y²", "−88", 0);
+
+ test("π", "3.141592654", 0);
+ test("e", "2.718281828", 0);
+
+ test("z=99", "99", 0);
+ test("longname=99", "99", 0);
+ //test("e=99", "", PARSER_ERR_BUILTIN_VARIABLE);
+
+ test("0+0", "0", 0);
+ test("1+1", "2", 0);
+ test("1+4", "5", 0);
+ test("4+1", "5", 0);
+ test("40000+0.001", "40000.001", 0);
+ test("0.001+40000", "40000.001", 0);
+ test("2-3", "−1", 0);
+ test("2−3", "−1", 0);
+ test("3−2", "1", 0);
+ test("40000−0.001", "39999.999", 0);
+ test("0.001−40000", "−39999.999", 0);
+ test("2*3", "6", 0);
+ test("2×3", "6", 0);
+ test("−2×3", "−6", 0);
+ test("2×−3", "−6", 0);
+ test("−2×−3", "6", 0);
+ test("6/3", "2", 0);
+ test("6÷3", "2", 0);
+ test("1÷2", "0.5", 0);
+ test("−6÷3", "−2", 0);
+ test("6÷−3", "−2", 0);
+ test("−6÷−3", "2", 0);
+ test("(−3)÷(−6)", "0.5", 0);
+ test("2÷2", "1", 0);
+ test("1203÷1", "1203", 0);
+ test("−0÷32352.689", "0", 0);
+ test("1÷4", "0.25", 0);
+ test("1÷3", "0.333333333", 0);
+ test("2÷3", "0.666666667", 0);
+ test("1÷0", "", PARSER_ERR_MP);
+ test("0÷0", "", PARSER_ERR_MP);
+
+ /* Precision */
+ test("1000000000000000−1000000000000000", "0", 0);
+ test("1000000000000000÷1000000000000000", "1", 0);
+ test("1000000000000000×0.000000000000001", "1", 0);
+
+ /* Order of operations */
+ test("1−0.9−0.1", "0", 0);
+ test("1+2×3", "7", 0);
+ test("1+(2×3)", "7", 0);
+ test("(1+2)×3", "9", 0);
+ test("(1+2×3)", "7", 0);
+
+ /* Percentage */
+ test("100%", "1", 0);
+ test("1%", "0.01", 0);
+ test("100+1%", "101", 0);
+ test("100−1%", "99", 0);
+ test("100×1%", "1", 0);
+ test("100÷1%", "10000", 0);
+
+ /* Factorial */
+ test("0!", "1", 0);
+ test("1!", "1", 0);
+ test("5!", "120", 0);
+ test("69!", "171122452428141311372468338881272839092270544893520369393648040923257279754140647424000000000000000", 0);
+ test("0.1!", "", PARSER_ERR_MP);
+ test("−1!", "−1", 0);
+ test("(−1)!", "", PARSER_ERR_MP);
+ test("−(1!)", "−1", 0);
+
+ /* Powers */
+ test("2²", "4", 0);
+ test("2³", "8", 0);
+ test("2¹⁰", "1024", 0);
+ test("(1+2)²", "9", 0);
+ test("(x)²", "4", 0);
+ test("|1−3|²", "4", 0);
+ test("|x|²", "4", 0);
+ test("0^0", "1", 0);
+ test("2^0", "1", 0);
+ test("2^1", "2", 0);
+ test("2^2", "4", 0);
+ test("2⁻¹", "0.5", 0);
+ //test("2⁻", "", PARSER_ERR_MP); // FIXME: Maybe an error in bison?
+ test("2^−1", "0.5", 0);
+ test("2^(−1)", "0.5", 0);
+ test("x⁻¹", "0.5", 0);
+ test("−10^2", "−100", 0);
+ test("(−10)^2", "100", 0);
+ test("−(10^2)", "−100", 0);
+ test("2^100", "1267650600228229401496703205376", 0);
+ test("4^3^2", "262144", 0);
+ test("4^(3^2)", "262144", 0);
+ test("(4^3)^2", "4096", 0);
+ test("√4", "2", 0);
+ test("√4−2", "0", 0);
+ test("∛8", "2", 0);
+ test("∜16", "2", 0);
+ test("₃√8", "2", 0);
+ test("₁₀√1024", "2", 0);
+ test("√(2+2)", "2", 0);
+ test("2√4", "4", 0);
+ test("2×√4", "4", 0);
+ test("Sqrt(4)", "2", 0);
+ test("Sqrt(2)", "1.414213562", 0);
+ test("4^0.5", "2", 0);
+ test("2^0.5", "1.414213562", 0);
+ test("₃√−8", "−2", 0);
+ test("(−8)^(1÷3)", "−2", 0);
+
+ test("0 mod 7", "0", 0);
+ test("6 mod 7", "6", 0);
+ test("7 mod 7", "0", 0);
+ test("8 mod 7", "1", 0);
+ test("−1 mod 7", "6", 0);
+
+ test("sgn 0", "0", 0); 
+ test("sgn 3", "1", 0);
+ test("sgn −3", "−1", 0);
+ test("⌊3⌋", "3", 0);
+ test("⌈3⌉", "3", 0);
+ test("[3]", "3", 0);
+ test("⌊−3⌋", "−3", 0);
+ test("⌈−3⌉", "−3", 0);
+ test("[−3]", "−3", 0);
+ test("⌊3.2⌋", "3", 0);
+ test("⌈3.2⌉", "4", 0);
+ test("[3.2]", "3", 0);
+ test("⌊−3.2⌋", "−4", 0);
+ test("⌈−3.2⌉", "−3", 0);
+ test("[−3.2]", "−3", 0);
+ test("⌊3.5⌋", "3", 0);
+ test("⌈3.5⌉", "4", 0);
+ test("[3.5]", "4", 0);
+ test("⌊−3.5⌋", "−4", 0);
+ test("⌈−3.5⌉", "−3", 0);
+ test("[−3.5]", "−4", 0);
+ test("⌊3.7⌋", "3", 0);
+ test("⌈3.7⌉", "4", 0);
+ test("[3.7]", "4", 0);
+ test("⌊−3.7⌋", "−4", 0);
+ test("⌈−3.7⌉", "−3", 0);
+ test("[−3.7]", "−4", 0);
+ test("{3.2}", "0.2", 0);
+ test("{−3.2}", "0.8", 0);
+
+ test("|1|", "1", 0);
+ test("|−1|", "1", 0);
+ test("|3−5|", "2", 0);
+ test("|x|", "2", 0);
+ test("abs 1", "1", 0);
+ test("abs (−1)", "1", 0);
+
+ test("log 0", "", PARSER_ERR_MP);
+ test("log 1", "0", 0);
+ test("log 2", "0.301029996", 0);
+ test("log 10", "1", 0);
+ test("log₁₀ 10", "1", 0);
+ test("log₂ 2", "1", 0);
+ test("2 log 2", "0.602059991", 0);
+
+ test("ln 0", "", PARSER_ERR_MP);
+ test("ln 1", "0", 0);
+ test("ln 2", "0.693147181", 0);
+ test("ln e", "1", 0);
+ test("2 ln 2", "1.386294361", 0);
+
+ options.angle_units = MP_DEGREES;
+ test("sin 0", "0", 0);
+ test("sin 45 − 1÷√2", "0", 0);
+ test("sin 20 + sin(−20)", "0", 0);
+ test("sin 90", "1", 0);
+ test("sin 180", "0", 0);
+ test("2 sin 90", "2", 0);
+ test("sin²45", "0.5", 0);
+
+ test("cos 0", "1", 0);
+ test("cos 45 − 1÷√2", "0", 0);
+ test("cos 20 − cos (−20)", "0", 0);
+ test("cos 90", "0", 0);
+ test("cos 180", "−1", 0);
+ test("2 cos 0", "2", 0);
+ test("cos²45", "0.5", 0);
+
+ test("tan 0", "0", 0);
+ test("tan 10 − sin 10÷cos 10", "0", 0);
+ test("tan 90", "", PARSER_ERR_MP);
+ test("tan 10", "0.176326981", 0);
+ test("tan²10", "0.031091204", 0);
+
+ test("cos⁻¹ 0", "90", 0);
+ test("cos⁻¹ 1", "0", 0);
+ test("cos⁻¹ (−1)", "180", 0);
+ test("cos⁻¹ (1÷√2)", "45", 0);
+
+ test("sin⁻¹ 0", "0", 0);
+ test("sin⁻¹ 1", "90", 0);
+ test("sin⁻¹ (−1)", "−90", 0);
+ test("sin⁻¹ (1÷√2)", "45", 0);
+
+ test("cosh 0", "1", 0);
+ test("cosh 10 − (e^10 + e^−10)÷2", "0", 0);
+
+ test("sinh 0", "0", 0);
+ test("sinh 10 − (e^10 − e^−10)÷2", "0", 0);
+ test("sinh (−10) + sinh 10", "0", 0);
+
+ test("cosh² (−5) − sinh² (−5)", "1", 0);
+ test("tanh 0", "0", 0);
+ test("tanh 10 − sinh 10 ÷ cosh 10", "0", 0);
+
+ test("atanh 0", "0", 0);
+ test("atanh (1÷10) − 0.5 ln(11÷9)", "0", 0);
+
+ options.angle_units = MP_DEGREES;
+ test("sin 90", "1", 0);
+
+ options.angle_units = MP_RADIANS;
+ test("sin (π÷2)", "1", 0); // FIXME: Shouldn't need brackets
+
+ options.angle_units = MP_GRADIANS;
+ test("sin 100", "1", 0);
+
+ /* Complex numbers */
+ options.angle_units = MP_DEGREES;
+ test("i", "i", 0);
+ test("−i", "−i", 0);
+ test("2i", "2i", 0);
+ test("1+i", "1+i", 0); 
+ test("i+1", "1+i", 0);
+ test("1−i", "1−i", 0); 
+ test("i−1", "−1+i", 0);
+ test("i×i", "−1", 0);
+ test("i÷i", "1", 0);
+ test("1÷i", "−i", 0);
+ test("|i|", "1", 0);
+ test("|3+4i|", "5", 0);
+ test("arg 0", "", PARSER_ERR_MP); 
+ test("arg 1", "0", 0);
+ test("arg (1+i)", "45", 0);
+ test("arg i", "90", 0);
+ test("arg (−1+i)", "135", 0);
+ test("arg −1", "180", 0);
+ test("arg (1+−i)", "−45", 0);
+ test("arg −i", "−90", 0);
+ test("arg (−1−i)", "−135", 0);
+ test("i⁻¹", "−i", 0);
+ test("√−1", "i", 0);
+ test("(−1)^0.5", "i", 0);
+ test("√−4", "2i", 0);
+ test("e^iπ", "−1", 0);
+ test("log (−10) − (1 + πi÷ln(10))", "0", 0);
+ test("ln (−e) − (1 + πi)", "0", 0);
+ test("sin(iπ÷4) − i×sinh(π÷4)", "0", 0);
+ test("cos(iπ÷4) − cosh(π÷4)", "0", 0);
+
+ /* Boolean */
+ test("0 and 0", "0", 0);
+ test("1 and 0", "0", 0);
+ test("0 and 1", "0", 0);
+ test("1 and 1", "1", 0);
+ test("3 and 5", "1", 0);
+
+ test("0 or 0", "0", 0); 
+ test("1 or 0", "1", 0);
+ test("0 or 1", "1", 0); 
+ test("1 or 1", "1", 0);
+ test("3 or 5", "7", 0);
+
+ test("0 xor 0", "0", 0);
+ test("1 xor 0", "1", 0);
+ test("0 xor 1", "1", 0);
+ test("1 xor 1", "0", 0);
+ test("3 xor 5", "6", 0);
+
+ options.base = 16;
+ test("ones 1", "FFFFFFFE", 0);
+ test("ones 7FFFFFFF", "80000000", 0);
+ test("twos 1", "FFFFFFFF", 0);
+ test("twos 7FFFFFFF", "80000001", 0);
+ test("~7A₁₆", "FFFFFF85", 0);
+
+ options.base = 2;
+ options.wordlen = 4;
+ test("1100∧1010", "1000", 0);
+ test("1100∨1010", "1110", 0);
+ test("1100⊻1010", "110", 0);
+ test("1100⊕1010", "110", 0);
+ //test("1100⊼1010", "0111", 0);
+ //test("1100⊽1010", "0001", 0);
+ //options.wordlen = 2;
+ //test("¬01₂", "10₂", 0);
+ //test("¬¬10₂", "10₂", 0);
+}
+
+
+static void
+print_number(MPNumber *x)
+{
+ int i, j;
+
+ printf("sign=%d exponent=%d fraction=%d", x->sign, x->exponent, x->fraction[0]);
+ for (i = 1; i < MP_SIZE; i++) {
+ for (j = i; j < MP_SIZE && x->fraction[j] == 0; j++);
+ if (j == MP_SIZE) {
+ printf(",...");
+ break;
+ }
+ printf(",%d", x->fraction[i]);
+ }
+}
+
+static void
+test_string(const char *number)
+{
+ MPNumber t;
+
+ mp_set_from_string(number, 10, &t);
+
+ printf("MPNumber(%s) -> {", number);
+ print_number(&t);
+ printf("}\n");
+}
+
+static void
+test_integer(int number)
+{
+ MPNumber t;
+
+ mp_set_from_integer(number, &t);
+
+ printf("MPNumber(%d) -> {", number);
+ print_number(&t);
+ printf("}\n");
+}
+
+#include "mp-private.h"
+static void
+test_numbers()
+{
+ printf("base=%d\n", MP_BASE);
+ test_integer(0);
+ test_integer(1);
+ test_integer(-1);
+ test_integer(2);
+ test_integer(9999);
+ test_integer(10000);
+ test_integer(10001);
+ test_integer(2147483647);
+
+ test_string("0");
+ test_string("1");
+ test_string("-1");
+ test_string("16383");
+ test_string("16384");
+ test_string("16385");
+ test_string("268435456");
+
+ test_string("0.1");
+ test_string("0.5");
+ test_string("0.25");
+ test_string("0.125");
+ test_string("0.0625");
+ test_string("0.00006103515625");
+ test_string("0.000030517578125");
+
+ test_string("1.00006103515625");
+ test_string("16384.00006103515625");
+}
+
+
+static void
+try(const char *string, bool result, bool expected)
+{
+ if ((result && !expected) || (!result && expected))
+ fail("%s -> %s, expected %s", string, expected ? "true" : "false", result ? "true" : "false");
+ else
+ pass("%s -> %s", string, result ? "true" : "false");
+}
+
+
+static void
+test_mp()
+{
+ MPNumber zero, one, minus_one;
+ 
+ mp_set_from_integer(0, &zero);
+ mp_set_from_integer(1, &one);
+ mp_set_from_integer(-1, &minus_one);
+ 
+ try("mp_is_zero(-1)", mp_is_zero(&minus_one), false);
+ try("mp_is_zero(0)", mp_is_zero(&zero), true);
+ try("mp_is_zero(1)", mp_is_zero(&one), false);
+
+ try("mp_is_negative(-1)", mp_is_negative(&minus_one), true);
+ try("mp_is_negative(0)", mp_is_negative(&zero), false);
+ try("mp_is_negative(1)", mp_is_negative(&one), false);
+
+ try("mp_is_integer(-1)", mp_is_integer(&minus_one), true);
+ try("mp_is_integer(0)", mp_is_integer(&zero), true);
+ try("mp_is_integer(1)", mp_is_integer(&one), true);
+
+ try("mp_is_positive_integer(-1)", mp_is_positive_integer(&minus_one), false);
+ try("mp_is_positive_integer(0)", mp_is_positive_integer(&zero), true);
+ try("mp_is_positive_integer(1)", mp_is_positive_integer(&one), true);
+
+ try("mp_is_natural(-1)", mp_is_natural(&minus_one), false);
+ try("mp_is_natural(0)", mp_is_natural(&zero), false);
+ try("mp_is_natural(1)", mp_is_natural(&one), true);
+
+ try("mp_is_complex(-1)", mp_is_complex(&minus_one), false);
+ try("mp_is_complex(0)", mp_is_complex(&zero), false);
+ try("mp_is_complex(1)", mp_is_complex(&one), false);
+
+ try("mp_is_equal(-1, -1)", mp_is_equal(&minus_one, &minus_one), true);
+ try("mp_is_equal(-1, 0)", mp_is_equal(&minus_one, &zero), false);
+ try("mp_is_equal(-1, 1)", mp_is_equal(&minus_one, &one), false);
+ try("mp_is_equal(0, -1)", mp_is_equal(&zero, &minus_one), false);
+ try("mp_is_equal(0, 0)", mp_is_equal(&zero, &zero), true);
+ try("mp_is_equal(0, 1)", mp_is_equal(&zero, &one), false);
+ try("mp_is_equal(1, -1)", mp_is_equal(&one, &minus_one), false);
+ try("mp_is_equal(1, 0)", mp_is_equal(&one, &zero), false);
+ try("mp_is_equal(1, 1)", mp_is_equal(&one, &one), true);
+
+ try("mp_is_greater_than(0, -1)", mp_is_greater_than (&zero, &minus_one), true); 
+ try("mp_is_greater_than(0, 0)", mp_is_greater_than (&zero, &zero), false);
+ try("mp_is_greater_than(0, 1)", mp_is_greater_than (&zero, &one), false);
+ try("mp_is_greater_than(1, -1)", mp_is_greater_than (&one, &minus_one), true); 
+ try("mp_is_greater_than(1, 0)", mp_is_greater_than (&one, &zero), true);
+ try("mp_is_greater_than(1, 1)", mp_is_greater_than (&one, &one), false);
+ try("mp_is_greater_than(-1, -1)", mp_is_greater_than (&minus_one, &minus_one), false); 
+ try("mp_is_greater_than(-1, 0)", mp_is_greater_than (&minus_one, &zero), false);
+ try("mp_is_greater_than(-1, 1)", mp_is_greater_than (&minus_one, &one), false);
+
+ try("mp_is_greater_equal(0, -1)", mp_is_greater_equal (&zero, &minus_one), true); 
+ try("mp_is_greater_equal(0, 0)", mp_is_greater_equal (&zero, &zero), true);
+ try("mp_is_greater_equal(0, 1)", mp_is_greater_equal (&zero, &one), false);
+ try("mp_is_greater_equal(1, -1)", mp_is_greater_equal (&one, &minus_one), true);
+ try("mp_is_greater_equal(1, 0)", mp_is_greater_equal (&one, &zero), true);
+ try("mp_is_greater_equal(1, 1)", mp_is_greater_equal (&one, &one), true);
+ try("mp_is_greater_equal(-1, -1)", mp_is_greater_equal (&minus_one, &minus_one), true);
+ try("mp_is_greater_equal(-1, 0)", mp_is_greater_equal (&minus_one, &zero), false);
+ try("mp_is_greater_equal(-1, 1)", mp_is_greater_equal (&minus_one, &one), false);
+
+ try("mp_is_less_than(0, -1)", mp_is_less_than (&zero, &minus_one), false); 
+ try("mp_is_less_than(0, 0)", mp_is_less_than (&zero, &zero), false);
+ try("mp_is_less_than(0, 1)", mp_is_less_than (&zero, &one), true);
+ try("mp_is_less_than(1, -1)", mp_is_less_than (&one, &minus_one), false); 
+ try("mp_is_less_than(1, 0)", mp_is_less_than (&one, &zero), false);
+ try("mp_is_less_than(1, 1)", mp_is_less_than (&one, &one), false);
+ try("mp_is_less_than(-1, -1)", mp_is_less_than (&minus_one, &minus_one), false); 
+ try("mp_is_less_than(-1, 0)", mp_is_less_than (&minus_one, &zero), true);
+ try("mp_is_less_than(-1, 1)", mp_is_less_than (&minus_one, &one), true);
+
+ try("mp_is_less_equal(0, -1)", mp_is_less_equal (&zero, &minus_one), false); 
+ try("mp_is_less_equal(0, 0)", mp_is_less_equal (&zero, &zero), true);
+ try("mp_is_less_equal(0, 1)", mp_is_less_equal (&zero, &one), true);
+ try("mp_is_less_equal(1, -1)", mp_is_less_equal (&one, &minus_one), false); 
+ try("mp_is_less_equal(1, 0)", mp_is_less_equal (&one, &zero), false);
+ try("mp_is_less_equal(1, 1)", mp_is_less_equal (&one, &one), true);
+ try("mp_is_less_equal(-1, -1)", mp_is_less_equal (&minus_one, &minus_one), true); 
+ try("mp_is_less_equal(-1, 0)", mp_is_less_equal (&minus_one, &zero), true);
+ try("mp_is_less_equal(-1, 1)", mp_is_less_equal (&minus_one, &one), true);
+}
+
+
+void
+unittest()
+{ 
+ test_mp();
+ test_numbers();
+ test_conversions();
+ test_equations();
+ exit(fails > 0 ? 1 : 0);
+}
diff --git a/src/unittest.h b/src/unittest.h
new file mode 100644
index 0000000..7eee87d
--- /dev/null
+++ b/src/unittest.h
@@ -0,0 +1,24 @@
+/* Copyright (c) 2008-2009 Robert Ancell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#ifndef UNITTEST_H
+#define UNITTEST_H
+
+void unittest(void);
+
+#endif /* UNITTEST_H */
author	Perberos <[email protected]>	2011-11-08 13:50:37 -0300
committer	Perberos <[email protected]>	2011-11-08 13:50:37 -0300
commit	2358ba4314dc6d757049bc4871ecf2922614b61b (patch)
tree	12e52f491560916f0458c87b2d98ffa94500cb0f /src
download	mate-calc-2358ba4314dc6d757049bc4871ecf2922614b61b.tar.bz2 mate-calc-2358ba4314dc6d757049bc4871ecf2922614b61b.tar.xz