dsource.org

Open Source Development for
the D Programming Language

Navigation

← Previous Changeset
Next Changeset →

Changeset 176

Timestamp:

01/02/08 15:20:05 (4 years ago)

Author:

BCS

Message:

added a bunch more rules
did a compile time performance tweak in backmath.d
improved automation in do.lisp

Files:

trunk/backmath/backmath.d (modified) (5 diffs)
trunk/backmath/do.lisp (modified) (4 diffs)
trunk/backmath/gen_code_for_template.lisp (modified) (1 diff)
trunk/backmath/generated_rules.d (modified) (10 diffs)
trunk/backmath/meta.lisp (modified) (6 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/backmath/backmath.d

r175	r176
157	157	private struct DivAR{}
158	158
	159	private mixin(import("generated_rules.d"));
	160
159	161	template Operate(T)
160	162	{
…	…
165	167	// Note: the code in generated_rules.d needs access to private memebers of
166	168	// this module.
167		~~mixin(import("generated_rules.d"));~~
168	169
169	170	TypeOfAdd!(T,V) opAdd(V)(V t) { TypeOfAdd!(T,V) ret; return ret; }
…	…
308	309	c=2;
309	310	d=3;
310		/+
	311
311	312	A + B - D = C; // 1 + b - 3 = 2; -> 4
312	313	assert(b == 4);
…	…
378	379	(B * A) = (B / C);
379	380	(B / A) = (B / C);
380		+/
	381
381	382	Z = (B * A) + E + ((B * C) + D);
382	383	Z = (B / A) + E + ((B * C) + D);
…	…
384	385	Z = (B / A) + E + ((B / C) + D);
385	386
386		// Z = (B * A) + ((B * C) + D);
387		// Z = (B / A) + ((B * C) + D);
388		// Z = (B * A) + ((B / C) + D);
389		// Z = (B / A) + ((B / C) + D);
390
391		// Z = (B * A) + E + (B * C);
392		// Z = (B / A) + E + (B * C);
393		// Z = (B * A) + E + (B / C);
394		// Z = (B / A) + E + (B / C);
395
396		// Z = (B * A) - E + ((B * C) - D);
397		// Z = (B / A) - E + ((B * C) - D);
398		// Z = (B * A) - E + ((B / C) - D);
399		// Z = (B / A) - E + ((B / C) - D);
400
401		// Z = (B * A) + ((B * C) - D);
402		// Z = (B / A) + ((B * C) - D);
403		// Z = (B * A) + ((B / C) - D);
404		// Z = (B / A) + ((B / C) - D);
405
406		// Z = (B * A) - E + (B * C);
407		// Z = (B / A) - E + (B * C);
408		// Z = (B * A) - E + (B / C);
409		// Z = (B / A) - E + (B / C);
	387	Z = (B * A) + ((B * C) + D);
	388	Z = (B / A) + ((B * C) + D);
	389	Z = (B * A) + ((B / C) + D);
	390	Z = (B / A) + ((B / C) + D);
	391
	392	Z = (B * A) + E + (B * C);
	393	Z = (B / A) + E + (B * C);
	394	Z = (B * A) + E + (B / C);
	395	Z = (B / A) + E + (B / C);
	396
	397	Z = (B * A) - E + ((B * C) - D);
	398	Z = (B / A) - E + ((B * C) - D);
	399	Z = (B * A) - E + ((B / C) - D);
	400	Z = (B / A) - E + ((B / C) - D);
	401
	402	Z = (B * A) + ((B * C) - D);
	403	Z = (B / A) + ((B * C) - D);
	404	Z = (B * A) + ((B / C) - D);
	405	Z = (B / A) + ((B / C) - D);
	406
	407	Z = (B * A) - E + (B * C);
	408	Z = (B / A) - E + (B * C);
	409	Z = (B * A) - E + (B / C);
	410	Z = (B / A) - E + (B / C);
410	411
411	412	Z = (B * A) + (B * C);
412		// Z = (B / A) + (B * C);
413		// Z = (B * A) + (B / C);
414		// Z = (B / A) + (B / C);
415		}
	413	Z = (B / A) + (B * C);
	414	Z = (B * A) + (B / C);
	415	Z = (B / A) + (B / C);
	416	}

trunk/backmath/do.lisp

r175	r176
	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	3	;;;;;
	4	;;;;; This is a program for atomating parts of
	5	;;;;; the rule generation process for BackMath
	6	;;;;;
	7	;;;;; For instruction on how to use it, look at
	8	;;;;; the end of the file.
	9	;;;;;
	10	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	11	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	12
1	13	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	14	;; convert in place a op> exp to a normal exp
…	…
383	395	)
384	396	)
	397	(
	398	(and ; (* a (/ 1 b))
	399	(partof ( cdr exp) )
	400	(something ( cadr exp) )
	401	; a (cadr exp)
	402	(partof ( cddr exp) )
	403	(partof ( caddr exp) )
	404	(something ( caaddr exp) )
	405	; / (caaddr exp)
	406	(equal '/ ( caaddr exp) )
	407	(partof ( cdaddr exp) )
	408	(something (car(cdaddr exp)))
	409	; 1 (car(cdaddr exp))
	410	(equal 1 (car(cdaddr exp)))
	411	(something (cdr(cdaddr exp)))
	412	(something (cadr(cdaddr exp)))
	413	; b (cadr(cdaddr exp))
	414	)
	415	`(/ ; (/ a b)
	416	,(cadr exp)
	417	,(cadr(cdaddr exp))
	418	)
	419	)
385	420
386	421	(
…	…
463	498	;(- (*> h x) (/> e x))
464	499
465		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
466		;;;; #1) Copy and pastes the requiered form here ;;;;;;;;;;
467		;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
468
469		(+ (/> k (-> h x)) (*> f (-> e x)))
470		)
471
472
473		;;;;;;;;; #2) Run the program
	500	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	501	;;;; #1) Copy and pastes the required form here ;;;;;;;;;;
	502	;;;; #2) Run the program ;;;;;;;;;;
	503	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	504
	505	(+ (> h x) (> f (-> e x)))
	506
	507	)
	508
	509
474	510	"#3) copy this expression for step 4"
475	511	(Convert_to_exp in)
…	…
479	515
480	516	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
481		;;;; #4) pastes expression from step 3 here ;;;;;;;;;;
482		;;;; #5) rear~~ange so that is is of the form: ;~~;;;;;;;;;
483		;;;; (*/ A (+- X B)) ;;;;;;;;;;
	517	;;;; #4) pastes expression from step 3 here ;;;;;;;;;
	518	;;;; #5) rearrange so that is is of the form: ;;;;;;;;;
	519	;;;; (*/ A (+- X B)) ;;;;;;;;;
484	520	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
485	521
486		(* (+ ~~K (/ 1 F))(+ (* X ) (/ (+(* H K) (/ E F)) (+ K (/ 1~~ F)))))
	522	(* (+ (/ H) (/ F)) (+ (* x ) (/ (/ E F)(+ (/ H) (/ F)))))
487	523
488	524	)

trunk/backmath/gen_code_for_template.lisp

r174	r176
24	24	" {}" nl
25	25	" static if(!is(TypeOf" (op_name opis) "))" nl
26		" static assert(false, `~~invalid~~ types used for " (op_name opis) ": (" (op_symb opis) " ` ~~ T.LispOf ~~ ` `~~ V.LispOf ~~ `)` );" nl
	26	" static assert(false, `unusable types used for " (op_name opis) ": (" (op_symb opis) " ` ~~ T.LispOf ~~ ` `~~ V.LispOf ~~ `)` );" nl
27	27	(if verbose
28	28	(concatenate

trunk/backmath/generated_rules.d

r175	r176
15	15	alias OpDivA!(OpAdd!(T.LHS, OpDiv!(Value!(1), V.LHS)), OpSubA!(OpDiv!(OpAdd!(OpMul!(T.RHS.LHS, T.LHS), OpDiv!(V.RHS.LHS, V.LHS)), OpAdd!(T.LHS, OpDiv!(Value!(1), V.LHS))), T.RHS.RHS)) TypeOfAdd;
16	16	else
	17	static if( /+ (+ (/> K (-> H X)) (/> E X)) -> (/> (+ K E) (-> (/ (* H K) (+ K E)) X)) +/
	18	is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.Op == SubA) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) &&
	19	is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined)
	20	&& is(T.RHS.RHS == V.RHS)
	21	)
	22	alias OpDivA!(OpAdd!(T.LHS, V.LHS), OpSubA!(OpDiv!(OpMul!(T.RHS.LHS, T.LHS), OpAdd!(T.LHS, V.LHS)), T.RHS.RHS)) TypeOfAdd;
	23	else
	24	static if( /+ (+ (/> K (-> H X)) (> E X)) -> (/> (+ K (/ 1 E)) (-> (/ ( H K) (+ K (/ 1 E))) X)) +/
	25	is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.Op == SubA) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) &&
	26	is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined)
	27	&& is(T.RHS.RHS == V.RHS)
	28	)
	29	alias OpDivA!(OpAdd!(T.LHS, OpDiv!(Value!(1), V.LHS)), OpSubA!(OpDiv!(OpMul!(T.RHS.LHS, T.LHS), OpAdd!(T.LHS, OpDiv!(Value!(1), V.LHS))), T.RHS.RHS)) TypeOfAdd;
	30	else
17	31	static if( /+ (+ (/> A (-> B X)) C) -> (/> A (-> (+ (/ C A) B) X)) +/
18	32	is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.Op == SubA) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) &&
…	…
36	50	alias OpDivA!(OpAdd!(T.LHS, V.LHS), OpAddA!(OpDiv!(OpAdd!(OpMul!(T.RHS.LHS, T.LHS), OpMul!(V.RHS.LHS, V.LHS)), OpAdd!(T.LHS, V.LHS)), T.RHS.RHS)) TypeOfAdd;
37	51	else
	52	static if( /+ (+ (/> K (+> H X)) (> F (+> E X))) -> (/> (+ K (/ 1 F)) (+> (/ (+ ( H K) (/ E F)) (+ K (/ 1 F))) X)) +/
	53	is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.Op == AddA) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) &&
	54	is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.Op == AddA) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined)
	55	&& is(T.RHS.RHS == V.RHS.RHS)
	56	)
	57	alias OpDivA!(OpAdd!(T.LHS, OpDiv!(Value!(1), V.LHS)), OpAddA!(OpDiv!(OpAdd!(OpMul!(T.RHS.LHS, T.LHS), OpDiv!(V.RHS.LHS, V.LHS)), OpAdd!(T.LHS, OpDiv!(Value!(1), V.LHS))), T.RHS.RHS)) TypeOfAdd;
	58	else
	59	static if( /+ (+ (/> K (+> H X)) (/> E X)) -> (/> (+ K E) (+> (/ (* H K) (+ K E)) X)) +/
	60	is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.Op == AddA) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) &&
	61	is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined)
	62	&& is(T.RHS.RHS == V.RHS)
	63	)
	64	alias OpDivA!(OpAdd!(T.LHS, V.LHS), OpAddA!(OpDiv!(OpMul!(T.RHS.LHS, T.LHS), OpAdd!(T.LHS, V.LHS)), T.RHS.RHS)) TypeOfAdd;
	65	else
	66	static if( /+ (+ (/> K (+> H X)) (> E X)) -> (/> (+ K (/ 1 E)) (+> (/ ( H K) (+ K (/ 1 E))) X)) +/
	67	is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.Op == AddA) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) &&
	68	is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined)
	69	&& is(T.RHS.RHS == V.RHS)
	70	)
	71	alias OpDivA!(OpAdd!(T.LHS, OpDiv!(Value!(1), V.LHS)), OpAddA!(OpDiv!(OpMul!(T.RHS.LHS, T.LHS), OpAdd!(T.LHS, OpDiv!(Value!(1), V.LHS))), T.RHS.RHS)) TypeOfAdd;
	72	else
38	73	static if( /+ (+ (/> A (+> B X)) C) -> (/> A (+> (- B (/ C A)) X)) +/
39	74	is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.Op == AddA) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) &&
…	…
56	91	)
57	92	alias OpDivA!(OpAdd!(OpDiv!(Value!(1), T.LHS), V.LHS), OpSubA!(OpDiv!(OpAdd!(OpMul!(T.RHS.LHS, OpDiv!(Value!(1), T.LHS)), OpMul!(V.RHS.LHS, V.LHS)), OpAdd!(OpDiv!(Value!(1), T.LHS), V.LHS)), T.RHS.RHS)) TypeOfAdd;
	93	else
	94	static if( /+ (+ (> K (-> H X)) (> F (-> E X))) -> (/> (+ (/ 1 K) (/ 1 F))
	95	(-> (/ (+ (/ E F) (/ H K)) (+ (/ 1 K) (/ 1 F))) X)) +/
	96	is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.Op == SubA) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) &&
	97	is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.Op == SubA) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined)
	98	&& is(T.RHS.RHS == V.RHS.RHS)
	99	)
	100	alias OpDivA!(OpAdd!(OpDiv!(Value!(1), T.LHS), OpDiv!(Value!(1), V.LHS)), OpSubA!(OpDiv!(OpAdd!(OpDiv!(V.RHS.LHS, V.LHS), OpDiv!(T.RHS.LHS, T.LHS)), OpAdd!(OpDiv!(Value!(1), T.LHS), OpDiv!(Value!(1), V.LHS))), T.RHS.RHS)) TypeOfAdd;
	101	else
	102	static if( /+ (+ (*> K (-> H X)) (/> E X)) -> (/> (+ E (/ 1 K)) (-> (/ (/ H K) (+ E (/ 1 K))) X)) +/
	103	is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.Op == SubA) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) &&
	104	is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined)
	105	&& is(T.RHS.RHS == V.RHS)
	106	)
	107	alias OpDivA!(OpAdd!(V.LHS, OpDiv!(Value!(1), T.LHS)), OpSubA!(OpDiv!(OpDiv!(T.RHS.LHS, T.LHS), OpAdd!(V.LHS, OpDiv!(Value!(1), T.LHS))), T.RHS.RHS)) TypeOfAdd;
	108	else
	109	static if( /+ (+ (> K (-> H X)) (> E X)) -> (/> (+ (/ 1 K) (/ 1 E)) (-> (/ (/ H K) (+ (/ 1 K) (/ 1 E))) X)) +/
	110	is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.Op == SubA) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) &&
	111	is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined)
	112	&& is(T.RHS.RHS == V.RHS)
	113	)
	114	alias OpDivA!(OpAdd!(OpDiv!(Value!(1), T.LHS), OpDiv!(Value!(1), V.LHS)), OpSubA!(OpDiv!(OpDiv!(T.RHS.LHS, T.LHS), OpAdd!(OpDiv!(Value!(1), T.LHS), OpDiv!(Value!(1), V.LHS))), T.RHS.RHS)) TypeOfAdd;
	115	else
	116	static if( /+ (+ (> K (+> H X)) (/> F (+> E X))) -> (/> (+ F (/ 1 K)) (+> (/ (+ (/ H K) ( E F)) (+ F (/ 1 K))) X)) +/
	117	is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.Op == AddA) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) &&
	118	is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.Op == AddA) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined)
	119	&& is(T.RHS.RHS == V.RHS.RHS)
	120	)
	121	alias OpDivA!(OpAdd!(V.LHS, OpDiv!(Value!(1), T.LHS)), OpAddA!(OpDiv!(OpAdd!(OpDiv!(T.RHS.LHS, T.LHS), OpMul!(V.RHS.LHS, V.LHS)), OpAdd!(V.LHS, OpDiv!(Value!(1), T.LHS))), T.RHS.RHS)) TypeOfAdd;
	122	else
	123	static if( /+ (+ (> K (+> H X)) (> F (+> E X))) -> (/> (+ (/ 1 K) (/ 1 F))
	124	(+> (/ (+ (/ H K) (/ E F)) (+ (/ 1 K) (/ 1 F))) X)) +/
	125	is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.Op == AddA) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) &&
	126	is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.Op == AddA) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined)
	127	&& is(T.RHS.RHS == V.RHS.RHS)
	128	)
	129	alias OpDivA!(OpAdd!(OpDiv!(Value!(1), T.LHS), OpDiv!(Value!(1), V.LHS)), OpAddA!(OpDiv!(OpAdd!(OpDiv!(T.RHS.LHS, T.LHS), OpDiv!(V.RHS.LHS, V.LHS)), OpAdd!(OpDiv!(Value!(1), T.LHS), OpDiv!(Value!(1), V.LHS))), T.RHS.RHS)) TypeOfAdd;
	130	else
	131	static if( /+ (+ (*> K (+> H X)) (/> E X)) -> (/> (+ (/ 1 K) E) (+> (/ (/ H K) (+ (/ 1 K) E)) X)) +/
	132	is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.Op == AddA) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) &&
	133	is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined)
	134	&& is(T.RHS.RHS == V.RHS)
	135	)
	136	alias OpDivA!(OpAdd!(OpDiv!(Value!(1), T.LHS), V.LHS), OpAddA!(OpDiv!(OpDiv!(T.RHS.LHS, T.LHS), OpAdd!(OpDiv!(Value!(1), T.LHS), V.LHS)), T.RHS.RHS)) TypeOfAdd;
	137	else
	138	static if( /+ (+ (> K (+> H X)) (> E X)) -> (/> (+ (/ 1 K) (/ 1 E)) (+> (/ (/ H K) (+ (/ 1 K) (/ 1 E))) X)) +/
	139	is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.Op == AddA) && is(T.RHS.LHS.DefP == Defined) && is(T.RHS.RHS.DefP == UnDefined) &&
	140	is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined)
	141	&& is(T.RHS.RHS == V.RHS)
	142	)
	143	alias OpDivA!(OpAdd!(OpDiv!(Value!(1), T.LHS), OpDiv!(Value!(1), V.LHS)), OpAddA!(OpDiv!(OpDiv!(T.RHS.LHS, T.LHS), OpAdd!(OpDiv!(Value!(1), T.LHS), OpDiv!(Value!(1), V.LHS))), T.RHS.RHS)) TypeOfAdd;
58	144	else
59	145	static if( /+ (+ (> A (+> B X)) C) -> (> A (+> (- B (* C A)) X)) +/
…	…
78	164	alias OpDivAR!(OpAdd!(T.LHS, V.LHS), T.RHS) TypeOfAdd;
79	165	else
	166	static if( /+ (+ (/> H X) (/> F (-> E X))) -> (/> (+ H F) (-> (/ (* E F) (+ H F)) X)) +/
	167	is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) &&
	168	is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.Op == SubA) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined)
	169	&& is(T.RHS == V.RHS.RHS)
	170	)
	171	alias OpDivA!(OpAdd!(T.LHS, V.LHS), OpSubA!(OpDiv!(OpMul!(V.RHS.LHS, V.LHS), OpAdd!(T.LHS, V.LHS)), T.RHS)) TypeOfAdd;
	172	else
	173	static if( /+ (+ (/> H X) (/> F (+> E X))) -> (/> (+ H F) (+> (/ (* E F) (+ H F)) X)) +/
	174	is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) &&
	175	is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.Op == AddA) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined)
	176	&& is(T.RHS == V.RHS.RHS)
	177	)
	178	alias OpDivA!(OpAdd!(T.LHS, V.LHS), OpAddA!(OpDiv!(OpMul!(V.RHS.LHS, V.LHS), OpAdd!(T.LHS, V.LHS)), T.RHS)) TypeOfAdd;
	179	else
	180	static if( /+ (+ (/> H X) (*> F (-> E X))) -> (/> (+ H (/ 1 F)) (-> (/ (/ E F) (+ H (/ 1 F))) X)) +/
	181	is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) &&
	182	is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.Op == SubA) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined)
	183	&& is(T.RHS == V.RHS.RHS)
	184	)
	185	alias OpDivA!(OpAdd!(T.LHS, OpDiv!(Value!(1), V.LHS)), OpSubA!(OpDiv!(OpDiv!(V.RHS.LHS, V.LHS), OpAdd!(T.LHS, OpDiv!(Value!(1), V.LHS))), T.RHS)) TypeOfAdd;
	186	else
	187	static if( /+ (+ (/> H X) (*> F (+> E X))) -> (/> (+ H (/ 1 F)) (+> (/ (/ E F) (+ H (/ 1 F))) X)) +/
	188	is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) &&
	189	is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.Op == AddA) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined)
	190	&& is(T.RHS == V.RHS.RHS)
	191	)
	192	alias OpDivA!(OpAdd!(T.LHS, OpDiv!(Value!(1), V.LHS)), OpAddA!(OpDiv!(OpDiv!(V.RHS.LHS, V.LHS), OpAdd!(T.LHS, OpDiv!(Value!(1), V.LHS))), T.RHS)) TypeOfAdd;
	193	else
80	194	static if( /+ (+ (/> H X) (/> C X)) -> (/> (+ H C) X) +/
81	195	is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) &&
…	…
84	198	)
85	199	alias OpDivA!(OpAdd!(T.LHS, V.LHS), T.RHS) TypeOfAdd;
	200	else
	201	static if( /+ (+ (/> H X) (*> E X)) -> (/> (+ H (/ 1 E)) X) +/
	202	is(T.Op == DivA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) &&
	203	is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined)
	204	&& is(T.RHS == V.RHS)
	205	)
	206	alias OpDivA!(OpAdd!(T.LHS, OpDiv!(Value!(1), V.LHS)), T.RHS) TypeOfAdd;
86	207	else
87	208	static if( /+ (+ (/> A (-R> B X)) C) -> (/> A (-R> (+ B (/ C A)) X)) +/
…	…
105	226	)
106	227	alias OpDivA!(OpAdd!(T.LHS, Value!(1)), T.RHS) TypeOfAdd;
	228	else
	229	static if( /+ (+ (> H X) (/> F (-> E X))) -> (/> (+ (/ 1 H) F) (-> (/ ( E F) (+ (/ 1 H) F)) X)) +/
	230	is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) &&
	231	is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.Op == SubA) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined)
	232	&& is(T.RHS == V.RHS.RHS)
	233	)
	234	alias OpDivA!(OpAdd!(OpDiv!(Value!(1), T.LHS), V.LHS), OpSubA!(OpDiv!(OpMul!(V.RHS.LHS, V.LHS), OpAdd!(OpDiv!(Value!(1), T.LHS), V.LHS)), T.RHS)) TypeOfAdd;
	235	else
	236	static if( /+ (+ (> H X) (/> F (+> E X))) -> (/> (+ (/ 1 H) F) (+> (/ ( E F) (+ (/ 1 H) F)) X)) +/
	237	is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) &&
	238	is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.Op == AddA) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined)
	239	&& is(T.RHS == V.RHS.RHS)
	240	)
	241	alias OpDivA!(OpAdd!(OpDiv!(Value!(1), T.LHS), V.LHS), OpAddA!(OpDiv!(OpMul!(V.RHS.LHS, V.LHS), OpAdd!(OpDiv!(Value!(1), T.LHS), V.LHS)), T.RHS)) TypeOfAdd;
	242	else
	243	static if( /+ (+ (> H X) (> F (-> E X))) -> (/> (+ (/ 1 H) (/ 1 F)) (-> (/ (/ E F) (+ (/ 1 H) (/ 1 F))) X)) +/
	244	is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) &&
	245	is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.Op == SubA) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined)
	246	&& is(T.RHS == V.RHS.RHS)
	247	)
	248	alias OpDivA!(OpAdd!(OpDiv!(Value!(1), T.LHS), OpDiv!(Value!(1), V.LHS)), OpSubA!(OpDiv!(OpDiv!(V.RHS.LHS, V.LHS), OpAdd!(OpDiv!(Value!(1), T.LHS), OpDiv!(Value!(1), V.LHS))), T.RHS)) TypeOfAdd;
	249	else
	250	static if( /+ (+ (> H X) (> F (+> E X))) -> (/> (+ (/ 1 H) (/ 1 F)) (+> (/ (/ E F) (+ (/ 1 H) (/ 1 F))) X)) +/
	251	is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) &&
	252	is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.Op == AddA) && is(V.RHS.LHS.DefP == Defined) && is(V.RHS.RHS.DefP == UnDefined)
	253	&& is(T.RHS == V.RHS.RHS)
	254	)
	255	alias OpDivA!(OpAdd!(OpDiv!(Value!(1), T.LHS), OpDiv!(Value!(1), V.LHS)), OpAddA!(OpDiv!(OpDiv!(V.RHS.LHS, V.LHS), OpAdd!(OpDiv!(Value!(1), T.LHS), OpDiv!(Value!(1), V.LHS))), T.RHS)) TypeOfAdd;
	256	else
	257	static if( /+ (+ (*> H X) (/> E X)) -> (/> (+ (/ 1 H) E) X) +/
	258	is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) &&
	259	is(V.Op == DivA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined)
	260	&& is(T.RHS == V.RHS)
	261	)
	262	alias OpDivA!(OpAdd!(OpDiv!(Value!(1), T.LHS), V.LHS), T.RHS) TypeOfAdd;
	263	else
	264	static if( /+ (+ (> H X) (> E X)) -> (/> (+ (/ 1 H) (/ 1 E)) X) +/
	265	is(T.Op == MulA) && is(T.LHS.DefP == Defined) && is(T.RHS.DefP == UnDefined) &&
	266	is(V.Op == MulA) && is(V.LHS.DefP == Defined) && is(V.RHS.DefP == UnDefined)
	267	&& is(T.RHS == V.RHS)
	268	)
	269	alias OpDivA!(OpAdd!(OpDiv!(Value!(1), T.LHS), OpDiv!(Value!(1), V.LHS)), T.RHS) TypeOfAdd;
107	270	else
108	271	static if( /+ (+ (> A (-R> B X)) C) -> (> A (-R> (+ B (* C A)) X)) +/
…	…
304	467	{}
305	468	static if(!is(TypeOfAdd))
306		static assert(false, `~~invalid~~ types used for Add: (+ ` ~ T.LispOf ~ ` `~ V.LispOf ~ `)` );
	469	static assert(false, `unusable types used for Add: (+ ` ~ T.LispOf ~ ` `~ V.LispOf ~ `)` );
307	470	}
308	471	template TypeOfSub(T, V)
…	…
739	902	{}
740	903	static if(!is(TypeOfSub))
741		static assert(false, `~~invalid~~ types used for Sub: (- ` ~ T.LispOf ~ ` `~ V.LispOf ~ `)` );
	904	static assert(false, `unusable types used for Sub: (- ` ~ T.LispOf ~ ` `~ V.LispOf ~ `)` );
742	905	}
743	906	template TypeOfMul(T, V)
…	…
948	1111	{}
949	1112	static if(!is(TypeOfMul))
950		static assert(false, `~~invalid~~ types used for Mul: (* ` ~ T.LispOf ~ ` `~ V.LispOf ~ `)` );
	1113	static assert(false, `unusable types used for Mul: (* ` ~ T.LispOf ~ ` `~ V.LispOf ~ `)` );
951	1114	}
952	1115	template TypeOfDiv(T, V)
…	…
1185	1348	{}
1186	1349	static if(!is(TypeOfDiv))
1187		static assert(false, `~~invalid~~ types used for Div: (/ ` ~ T.LispOf ~ ` `~ V.LispOf ~ `)` );
	1350	static assert(false, `unusable types used for Div: (/ ` ~ T.LispOf ~ ` `~ V.LispOf ~ `)` );
1188	1351	}
1189	1352

trunk/backmath/meta.lisp

r175	r176
267	267	; ((+ (*> h x) (+> e x)) ())
268	268	; ((+ (*> h x) (-> e x)) ())
269		~~; ((+ (> h x) (> e x)) (~~))
270		~~; ((+ (*> h x) (/> e x)) (~~))
	269	((+ (> H X) (> E X)) (/> (+ (/ 1 H) (/ 1 E)) X))
	270	((+ (*> H X) (/> E X)) (/> (+ (/ 1 H) E) X))
271	271	; ((+ (*> h x) (-r> e x)) ())
272	272	; ((+ (*> h x) (/r> e x)) ())
273		~~; ((+ (> h x) (> f (+> e x))) (~~))
274		~~; ((+ (> h x) (> f (-> e x))) (~~))
	273	((+ (> H X) (> F (+> E X))) (/> (+ (/ 1 H) (/ 1 F)) (+> (/ (/ E F) (+ (/ 1 H) (/ 1 F))) X)))
	274	((+ (> H X) (> F (-> E X))) (/> (+ (/ 1 H) (/ 1 F)) (-> (/ (/ E F) (+ (/ 1 H) (/ 1 F))) X)))
275	275	; ((+ (> h x) (> f (-r> e x))) ())
276		~~; ((+ (*> h x) (/> f (+> e x))) (~~))
277		~~; ((+ (*> h x) (/> f (-> e x))) (~~))
	276	((+ (> H X) (/> F (+> E X))) (/> (+ (/ 1 H) F) (+> (/ ( E F) (+ (/ 1 H) F)) X)))
	277	((+ (> H X) (/> F (-> E X))) (/> (+ (/ 1 H) F) (-> (/ ( E F) (+ (/ 1 H) F)) X)))
278	278	; ((+ (*> h x) (/> f (-r> e x))) ())
279	279	; ((+ (*> h x) (/r> f (+> e x))) ())
…	…
281	281	; ((+ (*> h x) (/r> f (-r> e x))) ())
282	282
283		((+ (/> h x) x) (/> (+ h 1) x)) ; (/> a x)
	283	((+ (/> h x) x) (/> (+ h 1) x)) ; (/> a x)
284	284	; ((+ (/> h x) (+> e x)) ())
285	285	; ((+ (/> h x) (-> e x)) ())
286		~~; ((+ (/> h x) (*> e x)) (~~))
	286	((+ (/> H X) (*> E X)) (/> (+ H (/ 1 E)) X))
287	287	((+ (/> h x) (/> c x)) (/> (+ h c) x))
288	288	; ((+ (/> h x) (-r> e x)) ())
289	289	; ((+ (/> h x) (/r> e x)) ())
290		~~; ((+ (/> h x) (*> f (+> e x))) (~~))
291		~~; ((+ (/> h x) (*> f (-> e x))) (~~))
	290	((+ (/> H X) (*> F (+> E X))) (/> (+ H (/ 1 F)) (+> (/ (/ E F) (+ H (/ 1 F))) X)))
	291	((+ (/> H X) (*> F (-> E X))) (/> (+ H (/ 1 F)) (-> (/ (/ E F) (+ H (/ 1 F))) X)))
292	292	; ((+ (/> h x) (*> f (-r> e x))) ())
293		~~; ((+ (/> h x) (/> f (+> e x))) (~~))
294		~~; ((+ (/> h x) (/> f (-> e x))) (~~))
	293	((+ (/> H X) (/> F (+> E X))) (/> (+ H F) (+> (/ (* E F) (+ H F)) X)))
	294	((+ (/> H X) (/> F (-> E X))) (/> (+ H F) (-> (/ (* E F) (+ H F)) X)))
295	295	; ((+ (/> h x) (/> f (-r> e x))) ())
296	296	; ((+ (/> h x) (/r> f (+> e x))) ())
…	…
335	335	; ((+ (*> k (+> h x)) (+> e x)) ())
336	336	; ((+ (*> k (+> h x)) (-> e x)) ())
337		~~; ((+ (> k (+> h x)) (> e x)) (~~))
338		~~; ((+ (*> k (+> h x)) (/> e x)) (~~))
	337	((+ (> K (+> H X)) (> E X)) (/> (+ (/ 1 K) (/ 1 E)) (+> (/ (/ H K) (+ (/ 1 K) (/ 1 E))) X)))
	338	((+ (*> K (+> H X)) (/> E X)) (/> (+ (/ 1 K) E) (+> (/ (/ H K) (+ (/ 1 K) E)) X)))
339	339	; ((+ (*> k (+> h x)) (-r> e x)) ())
340	340	; ((+ (*> k (+> h x)) (/r> e x)) ())
341		~~; ((+ (> k (+> h x)) (> f (+> e x))) (~~))
	341	((+ (> K (+> H X)) (> F (+> E X))) (/> (+ (/ 1 K) (/ 1 F)) (+> (/ (+ (/ H K) (/ E F)) (+ (/ 1 K) (/ 1 F))) X)))
342	342	; ((+ (> k (+> h x)) (> f (-> e x))) ())
343	343	; ((+ (> k (+> h x)) (> f (-r> e x))) ())
344		~~; ((+ (*> k (+> h x)) (/> f (+> e x))) (~~))
	344	((+ (> K (+> H X)) (/> F (+> E X))) (/> (+ F (/ 1 K)) (+> (/ (+ (/ H K) ( E F)) (+ F (/ 1 K))) X)))
345	345	; ((+ (*> k (+> h x)) (/> f (-> e x))) ())
346	346	; ((+ (*> k (+> h x)) (/> f (-r> e x))) ())
…	…
352	352	; ((+ (*> k (-> h x)) (+> e x)) ())
353	353	; ((+ (*> k (-> h x)) (-> e x)) ())
354		~~; ((+ (> k (-> h x)) (> e x)) (~~))
355		~~; ((+ (*> k (-> h x)) (/> e x)) (~~))
	354	((+ (> K (-> H X)) (> E X)) (/> (+ (/ 1 K) (/ 1 E)) (-> (/ (/ H K) (+ (/ 1 K) (/ 1 E))) X)))
	355	((+ (*> K (-> H X)) (/> E X)) (/> (+ E (/ 1 K)) (-> (/ (/ H K) (+ E (/ 1 K))) X)))
356	356	; ((+ (*> k (-> h x)) (-r> e x)) ())
357	357	; ((+ (*> k (-> h x)) (/r> e x)) ())
358	358	; ((+ (> k (-> h x)) (> f (+> e x))) ())
359		~~; ((+ (> k (-> h x)) (> f (-> e x))) (~~))
	359	((+ (> K (-> H X)) (> F (-> E X))) (/> (+ (/ 1 K) (/ 1 F)) (-> (/ (+ (/ E F) (/ H K)) (+ (/ 1 K) (/ 1 F))) X)))
360	360	; ((+ (> k (-> h x)) (> f (-r> e x))) ())
361	361	; ((+ (*> k (-> h x)) (/> f (+> e x))) ())
…	…
387	387	; ((+ (/> k (+> h x)) (+> e x)) ())
388	388	; ((+ (/> k (+> h x)) (-> e x)) ())
389		~~; ((+ (/> k (+> h x)) (*> e x)) (~~))
390		~~; ((+ (/> k (+> h x)) (/> e x)) (~~))
	389	((+ (/> K (+> H X)) (> E X)) (/> (+ K (/ 1 E)) (+> (/ ( H K) (+ K (/ 1 E))) X)))
	390	((+ (/> K (+> H X)) (/> E X)) (/> (+ K E) (+> (/ (* H K) (+ K E)) X)))
391	391	; ((+ (/> k (+> h x)) (-r> e x)) ())
392	392	; ((+ (/> k (+> h x)) (/r> e x)) ())
393		~~; ((+ (/> k (+> h x)) (*> f (+> e x))) (~~))
	393	((+ (/> K (+> H X)) (> F (+> E X))) (/> (+ K (/ 1 F)) (+> (/ (+ ( H K) (/ E F)) (+ K (/ 1 F))) X)))
394	394	; ((+ (/> k (+> h x)) (*> f (-> e x))) ())
395	395	; ((+ (/> k (+> h x)) (*> f (-r> e x))) ())
…	…
404	404	; ((+ (/> k (-> h x)) (+> e x)) ())
405	405	; ((+ (/> k (-> h x)) (-> e x)) ())
406		~~; ((+ (/> k (-> h x)) (*> e x)) (~~))
407		~~; ((+ (/> k (-> h x)) (/> e x)) (~~))
	406	((+ (/> K (-> H X)) (> E X)) (/> (+ K (/ 1 E)) (-> (/ ( H K) (+ K (/ 1 E))) X)))
	407	((+ (/> K (-> H X)) (/> E X)) (/> (+ K E) (-> (/ (* H K) (+ K E)) X)))
408	408	; ((+ (/> k (-> h x)) (-r> e x)) ())
409	409	; ((+ (/> k (-> h x)) (/r> e x)) ())

Download in other formats:

© Copyright 2004-2012 - The Sankaty Group, Inc. All rights reserved.

Make a Donation

Privacy Statement Terms of Service