eigenmath/print.cpp

#include "stdafx.h"
#include "defs.h"

extern int display_flag;
extern void displaychar(int);

int out_index, out_length;
char *out_str;
static int char_count, last_char;

//static void print_expr(U *);
//static void print_multiply_sign(void);
//static void print_denom(U *, int);
//static void print_a_over_b(U *);
//static int is_denominator(U *);
//static int any_denominators(U *);
int isnegativeterm(U *);
//static void print_subexpr(U *);
//static void print_index_function(U *);
//static void print_factorial_function(U *);
//static int sign_of_term(U *);

extern int test_flag;

char *power_str = "^";

void
print(U *p)
{
	print_expr(p);
}

void
printline(U *p)
{
	print_expr(p);
	print_char('\n');
}

void
print_subexpr(U *p)
{
	print_char('(');
	print_expr(p);
	print_char(')');
}

void
print_expr(U *p)
{
	if (isadd(p)) {
		p = cdr(p);
		if (sign_of_term(car(p)) == '-')
			print_str("-");
		print_term(car(p));
		p = cdr(p);
		while (iscons(p)) {
			if (sign_of_term(car(p)) == '+')
				if (test_flag == 0)
					print_str(" + ");
				else
					print_str("+");
			else
				if (test_flag == 0)
					print_str(" - ");
				else
					print_str("-");
			print_term(car(p));
			p = cdr(p);
		}
	} else {
		if (sign_of_term(p) == '-')
			print_str("-");
		print_term(p);
	}
}

int
sign_of_term(U *p)
{
	if (car(p) == symbol(MULTIPLY) && isnum(cadr(p)) && lessp(cadr(p), zero))
		return '-';
	else if (isnum(p) && lessp(p, zero))
		return '-';
	else
		return '+';
}

#define A p3
#define B p4

void
print_a_over_b(U *p)
{
	int flag, n, d;
	U *p1, *p2;

	save();

	// count numerators and denominators

	n = 0;
	d = 0;

	p1 = cdr(p);
	p2 = car(p1);

	if (isrational(p2)) {
		push(p2);
		mp_numerator();
		absval();
		A = pop();
		push(p2);
		mp_denominator();
		B = pop();
		if (!isplusone(A))
			n++;
		if (!isplusone(B))
			d++;
		p1 = cdr(p1);
	} else {
		A = one;
		B = one;
	}

	while (iscons(p1)) {
		p2 = car(p1);
		if (is_denominator(p2))
			d++;
		else
			n++;
		p1 = cdr(p1);
	}

	if (n == 0)
		print_char('1');
	else {
		flag = 0;
		p1 = cdr(p);
		if (isrational(car(p1)))
			p1 = cdr(p1);
		if (!isplusone(A)) {
			print_factor(A);
			flag = 1;
		} 
		while (iscons(p1)) {
			p2 = car(p1);
			if (is_denominator(p2))
				;
			else {
				if (flag)
					print_multiply_sign();
				print_factor(p2);
				flag = 1;
			}
			p1 = cdr(p1);
		}
	}

	if (test_flag == 0)
		print_str(" / ");
	else
		print_str("/");

	if (d > 1)
		print_char('(');


	flag = 0;
	p1 = cdr(p);

	if (isrational(car(p1)))
		p1 = cdr(p1);

	if (!isplusone(B)) {
		print_factor(B);
		flag = 1;
	}

	while (iscons(p1)) {
		p2 = car(p1);
		if (is_denominator(p2)) {
			if (flag)
				print_multiply_sign();
			print_denom(p2, d);
			flag = 1;
		}
		p1 = cdr(p1);
	}

	if (d > 1)
		print_char(')');

	restore();
}

void
print_term(U *p)
{
	if (car(p) == symbol(MULTIPLY) && any_denominators(p)) {
		print_a_over_b(p);
		return;
	}

	if (car(p) == symbol(MULTIPLY)) {
		p = cdr(p);

		// coeff -1?

		if (isminusone(car(p))) {
//			print_char('-');
			p = cdr(p);
		}

		print_factor(car(p));
		p = cdr(p);
		while (iscons(p)) {
			print_multiply_sign();
			print_factor(car(p));
			p = cdr(p);
		}
	} else
		print_factor(p);
}

// prints stuff after the divide symbol "/"

// d is the number of denominators

#define BASE p1
#define EXPO p2

void
print_denom(U *p, int d)
{
	save();

	BASE = cadr(p);
	EXPO = caddr(p);

	// i.e. 1 / (2^(1/3))

	if (d == 1 && !isminusone(EXPO))
		print_char('(');

	if (isfraction(BASE) || car(BASE) == symbol(ADD) || car(BASE) == symbol(MULTIPLY) || car(BASE) == symbol(POWER) || lessp(BASE, zero)) {
			print_char('(');
			print_expr(BASE);
			print_char(')');
	} else
		print_expr(BASE);

	if (isminusone(EXPO)) {
		restore();
		return;
	}

	if (test_flag == 0)
		print_str(power_str);
	else
		print_char('^');

	push(EXPO);
	negate();
	EXPO = pop();

	if (isfraction(EXPO) || car(EXPO) == symbol(ADD) || car(EXPO) == symbol(MULTIPLY) || car(EXPO) == symbol(POWER)) {
		print_char('(');
		print_expr(EXPO);
		print_char(')');
	} else
		print_expr(EXPO);

	if (d == 1)
		print_char(')');

	restore();
}

void
print_factor(U *p)
{
	if (isnum(p)) {
		print_number(p);
		return;
	}

	if (isstr(p)) {
		//print_str("\"");
		print_str(p->u.str);
		//print_str("\"");
		return;
	}

	if (istensor(p)) {
		print_tensor(p);
		return;
	}

	if (isadd(p) || car(p) == symbol(MULTIPLY)) {
		print_str("(");
		print_expr(p);
		print_str(")");
		return;
	}

	if (car(p) == symbol(POWER)) {

		if (equal(p, imaginaryunit)) {
			print_str("i");
			return;
		}

		if (cadr(p) == symbol(E)) {
			print_str("exp(");
			print_expr(caddr(p));
			print_str(")");
			return;
		}

		if (isminusone(caddr(p))) {
			if (test_flag == 0)
				print_str("1 / ");
			else
				print_str("1/");
			if (iscons(cadr(p))) {
				print_str("(");
				print_expr(cadr(p));
				print_str(")");
			} else
				print_expr(cadr(p));
			return;
		}

		if (isadd(cadr(p)) || caadr(p) == symbol(MULTIPLY) || caadr(p) == symbol(POWER) || isnegativenumber(cadr(p))) {
			print_str("(");
			print_expr(cadr(p));
			print_str(")");
		} else if (isnum(cadr(p)) && (lessp(cadr(p), zero) || isfraction(cadr(p)))) {
			print_str("(");
			print_factor(cadr(p));
			print_str(")");
		} else
			print_factor(cadr(p));
		if (test_flag == 0)
			//print_str(" ^ ");
			print_str(power_str);
		else
			print_str("^");
		if (iscons(caddr(p)) || isfraction(caddr(p)) || (isnum(caddr(p)) && lessp(caddr(p), zero))) {
			print_str("(");
			print_expr(caddr(p));
			print_str(")");
		} else
			print_factor(caddr(p));
		return;
	}

//	if (car(p) == _list) {
//		print_str("{");
//		p = cdr(p);
//		if (iscons(p)) {
//			print_expr(car(p));
//			p = cdr(p);
//		}
//		while (iscons(p)) {
//			print_str(",");
//			print_expr(car(p));
//			p = cdr(p);
//		}
//		print_str("}");
//		return;
//	}

	if (car(p) == symbol(INDEX) && issymbol(cadr(p))) {
		print_index_function(p);
		return;
	}

	if (car(p) == symbol(FACTORIAL)) {
		print_factorial_function(p);
		return;
	}

	if (iscons(p)) {
		//if (car(p) == symbol(FORMAL) && cadr(p)->k == SYM) {
		//	print_str(((struct symbol *) cadr(p))->name);
		//	return;
		//}
		print_factor(car(p));
		p = cdr(p);
		print_str("(");
		if (iscons(p)) {
			print_expr(car(p));
			p = cdr(p);
			while (iscons(p)) {
				if (test_flag == 0)
					print_str(",");
				else
					print_str(",");
				print_expr(car(p));
				p = cdr(p);
			}
		}
		print_str(")");
		return;
	}

	if (p == symbol(DERIVATIVE))
		print_char('d');
	else if (p == symbol(E))
		print_str("exp(1)");
	else if (p == symbol(PI))
		print_str("pi");
	else
		print_str(get_printname(p));
}

void
print_index_function(U *p)
{
	p = cdr(p);
	if (caar(p) == symbol(ADD) || caar(p) == symbol(MULTIPLY) || caar(p) == symbol(POWER) || caar(p) == symbol(FACTORIAL))
		print_subexpr(car(p));
	else
		print_expr(car(p));
	print_char('[');
	p = cdr(p);
	if (iscons(p)) {
		print_expr(car(p));
		p = cdr(p);
		while(iscons(p)) {
			print_char(',');
			print_expr(car(p));
			p = cdr(p);
		}
	}
	print_char(']');
}

void
print_factorial_function(U *p)
{
	p = cadr(p);
	if (car(p) == symbol(ADD) || car(p) == symbol(MULTIPLY) || car(p) == symbol(POWER) || car(p) == symbol(FACTORIAL))
		print_subexpr(p);
	else
		print_expr(p);
	print_char('!');
}

void
print_tensor(U *p)
{
	int k = 0;
	print_tensor_inner(p, 0, &k);
}

void
print_tensor_inner(U *p, int j, int *k)
{
	int i;
	print_str("(");
	for (i = 0; i < p->u.tensor->dim[j]; i++) {
		if (j + 1 == p->u.tensor->ndim) {
			print_expr(p->u.tensor->elem[*k]);
			*k = *k + 1;
		} else
			print_tensor_inner(p, j + 1, k);
		if (i + 1 < p->u.tensor->dim[j]) {
			if (test_flag == 0)
				print_str(",");
			else
				print_str(",");
		}
	}
	print_str(")");
}

void
print_str(char *s)
{
	while (*s)
		print_char(*s++);
}

void
print_char(int c)
{
	last_char = c;
	char_count++;
//	if (display_flag == 1)
//		displaychar(c);
//	else
		printchar(c);
}

void
print_function_definition(U *p)
{
	print_str(get_printname(p));
	print_arg_list(cadr(p->u.sym.binding));
	print_str("=");
	print_expr(caddr(p->u.sym.binding));
	print_str("\n");
}

void
print_arg_list(U *p)
{
	print_str("(");
	if (iscons(p)) {
		print_str(get_printname(car(p)));
		p = cdr(p);
		while (iscons(p)) {
			print_str(",");
			print_str(get_printname(car(p)));
			p = cdr(p);
		}
	}
	print_str(")");
}

void
print_lisp(U *p)
{
	print1(p);
	print_str("\n");
}

void
print1(U *p)
{
	switch (p->k) {
	case CONS:
		print_str("(");
		print1(car(p));
		p = cdr(p);
		while (iscons(p)) {
			print_str(" ");
			print1(car(p));
			p = cdr(p);
		}
		if (p != symbol(NIL)) {
			print_str(" . ");
			print1(p);
		}
		print_str(")");
		break;
	case STR:
		//print_str("\"");
		print_str(p->u.str);
		//print_str("\"");
		break;
	case NUM:
	case DOUBLE:
		print_number(p);
		break;
	case SYM:
		print_str(get_printname(p));
		break;
	default:
		print_str("<tensor>");
		break;
	}
}

void
print_multiply_sign(void)
{
	if (test_flag == 0)
		print_str(" ");
	else
		print_str("*");
}

int
is_denominator(U *p)
{
	if (car(p) == symbol(POWER) && cadr(p) != symbol(E) && isnegativeterm(caddr(p)))
		return 1;
	else
		return 0;
}

// don't consider the leading fraction

// we want 2/3*a*b*c instead of 2*a*b*c/3

int
any_denominators(U *p)
{
	U *q;
	p = cdr(p);
//	if (isfraction(car(p)))
//		return 1;
	while (iscons(p)) {
		q = car(p);
		if (is_denominator(q))
			return 1;
		p = cdr(p);
	}
	return 0;
}