*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <glib/gi18n.h>

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#ifndef FINANCIAL_H

/* $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.

* WITHOUT ANY WARRANTY; without even the implied warranty of

* 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

*/

#include <stdio.h>

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());

fprintf(stderr, "Error %d\n", ret);

else {

mp_cast_to_string(&z, 10, 10, 9, 1, result_str, MAXLINE);

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <stdlib.h>

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <glib/gi18n.h>

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#ifndef MATH_BUTTONS_H

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <string.h>

{

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));

//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

}

math_display_init(MathDisplay *display)

{

display->priv = G_TYPE_INSTANCE_GET_PRIVATE (display, math_display_get_type(), MathDisplayPrivate);

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#ifndef MATH_DISPLAY_H

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <stdlib.h>

GList *undo_stack; /* History of expression mode states */

GList *redo_stack;

gboolean in_undo_operation;

gboolean in_reformat;

gboolean in_delete;

get_ans_offsets(MathEquation *equation, gint *start, gint *end)

{

GtkTextIter iter;

if (!equation->priv->ans_start) {

*start = *end = -1;

return;

if (c == '\0')

break;

read_iter = g_utf8_next_char(read_iter);

offset++;

}

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)

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;

}

equation->priv->redo_stack = NULL;

state = get_current_state(equation);

}

apply_state(MathEquation *equation, MathEquationState *state)

{

GtkTextIter cursor;

/* Disable undo detection */

equation->priv->in_undo_operation = TRUE;

{

GList *link;

MathEquationState *state;

if (!equation->priv->undo_stack) {

math_equation_set_status(equation,

/* Error shown when trying to undo with no undo history */

void

math_equation_set_source_currency(MathEquation *equation, const gchar *currency)

{

if (!currency || currency[0] == '\0')

currency = currency_names[0].short_name;

void

math_equation_set_target_currency(MathEquation *equation, const gchar *currency)

{

if (!currency || currency[0] == '\0')

currency = currency_names[0].short_name;

g_free(equation->priv->state.status);

equation->priv->state.status = g_strdup(status);

}

for (c = lower_name; *c; c++)

*c = tolower(*c);

strcmp(lower_name, "ans") == 0) {

g_free (lower_name);

return 1;

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);

}

g_string_append_c(equation_text, ')');

n_brackets--;

}

result = parse(equation, equation_text->str, &z, &error_token);

g_string_free(equation_text, TRUE);

if (error_token)

free(error_token);

if (message) {

math_equation_set_status(equation, message);

g_free(message);

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"));

math_equation_delete(MathEquation *equation)

{

gint cursor;

g_object_get(G_OBJECT(equation), "cursor-position", &cursor, NULL);

if (cursor >= gtk_text_buffer_get_char_count(GTK_TEXT_BUFFER(equation)))

g_value_set_string(value, self->priv->state.status);

break;

case PROP_DISPLAY:

g_value_set_string(value, text);

g_free(text);

break;

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_param_spec_int("base",

"base",

"Default number base (derived from number-format)",

G_PARAM_READWRITE));

g_object_class_install_property(object_class,

PROP_WORD_SIZE,

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)

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)

{

return FALSE;

}

GtkTextIter *start,

GtkTextIter *end,

gpointer user_data)

if (equation->priv->in_reformat)

return;

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);

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_after(equation, "insert-text", G_CALLBACK(insert_text_cb), equation);

g_signal_connect_after(equation, "delete-range", G_CALLBACK(delete_range_cb), equation);

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("");

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#ifndef MATH_EQUATION_H

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <glib/gi18n.h>

MathPreferencesDialog *

math_preferences_dialog_new(MathEquation *equation)

return g_object_new (math_preferences_get_type(), "equation", equation, NULL);

}

static void

angle_unit_cb(MathEquation *equation, GParamSpec *spec, MathPreferencesDialog *dialog)

{

}

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#ifndef MATH_PREFERENCES_H

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <stdio.h>

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#ifndef MATH_VARIABLES_H

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <glib/gi18n.h>

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#ifndef MATH_WINDOW_H

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <stdio.h>

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <stdlib.h>

{

int i;

int64_t z = 0, v;

/* |x| <= 1 */

if (x->sign == 0 || x->exponent <= 0)

return 0;

t = z;

z = z * MP_BASE + x->fraction[i];

/* Check for overflow */

if (z <= t)

return 0;

{

int i;

uint64_t z = 0, v;

/* x <= 1 */

if (x->sign <= 0 || x->exponent <= 0)

return 0;

t = z;

z = z * MP_BASE + x->fraction[i];

/* Check for overflow */

if (z <= t)

return 0;

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);

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <stdlib.h>

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <stdio.h>

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 *inv_name;

int result;

inv_name = malloc(sizeof(char) * (strlen(name) + strlen("⁻¹") + 1));

strcpy(inv_name, name);

strcat(inv_name, "⁻¹");

name2 = malloc(sizeof(char) * (strlen(name) + strlen("?") + 1));

sprintf(name2, "%s?", name);

}

return name2;

}

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#ifndef MP_EQUATION_PRIVATE_H

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <ctype.h>

{

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;

{"g", "0.001"},

{NULL, NULL}

};

const char *time_units[][2] = {

{"year", "31557600"},

{"years", "31557600"},

if (state->options->convert)

return state->options->convert(x, x_units, z_units, z, state->options->callback_data);

return 0;

}

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#ifndef MP_EQUATION_H

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#ifndef MP_INTERNAL_H

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <stdlib.h>

break;

q *= 2;

/* t = t / (√(t² + 1) + 1) */

mp_multiply(&t2, &t2, z);

mp_add_integer(z, 1, z);

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <stdlib.h>

z->sign = x->im_sign;

z->exponent = x->im_exponent;

memcpy(z->fraction, x->im_fraction, sizeof(int) * MP_SIZE);

z->im_sign = 0;

z->im_exponent = 0;

memset(z->im_fraction, 0, sizeof(int) * MP_SIZE);

z->sign = y_sign;

return;

}

else if (mp_is_zero(y)) {

mp_set_from_mp(x, z);

return;

else if (mp_is_negative(x))

mp_set_from_integer(-1, z);

else

}

void

mp_is_integer(const MPNumber *x)

{

MPNumber t1, t2, t3;

if (mp_is_complex(x))

return false;

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 */

int c, i, xi;

MPNumber r;

if (x->sign == 0 || y->sign == 0) {

mp_set_from_integer(0, z);

return;

/* Clear complex part */

z->im_sign = 0;

z->im_exponent = 0;

/* NORMALIZE AND ROUND RESULT */

// FIXME: Use stack variable because of mp_normalize brokeness

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);

z->im_sign = 0;

z->im_exponent = 0;

mp_normalize(z);

}

void

mp_reciprocal(const MPNumber *x, MPNumber *z)

if (mp_is_complex(x)) {

MPNumber t1, t2;

MPNumber real_x, im_x;

mp_set_from_integer(0, z);

return;

}

/* x^1 = x */

if (n == 1) {

mp_set_from_mp(x, z);

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

/* This maths library is based on the MP multi-precision floating-point

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#include <stdlib.h>

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

*/

#ifndef UNITTEST_H