       rules for using functions as basis vectors

• To: mathgroup at smc.vnet.net
• Subject: [mg67110] rules for using functions as basis vectors
• From: Kenny Stephens <kstephens at hsutx.edu>
• Date: Fri, 9 Jun 2006 01:09:23 -0400 (EDT)
• Sender: owner-wri-mathgroup at wolfram.com

```Thanks for the help but I'm hesitant to alter the attributes of Dot.
Also, it is not the orderless aspect of Dot that gives me my main
difficulty. I do not know how to specify the necessary rules. Here is an
updated version of my code.

(* here are the rules for dot products between the basis elements *)
{t /: t[u_].t[u_] := 1, t /: t[u_].n[u_] := 0, t /: t[u_].b[u_] := 0};
{n /: n[u_].t[u_] := 0, n /: n[u_].n[u_] := 1, n /: n[u_].b[u_] := 0};
{b /: b[u_].t[u_] := 0, b /: b[u_].n[u_] := 0, b /: b[u_].b[u_] := 1};

(* here are the relations between derivatives of the basis elements *)
(* and the defining curve from which the basis is derived, i.e., the *)
(* Frenet-Seret relations *)
{Derivative[r][u_] := t[u],
Derivative[t][u_] := \[Kappa][u] n[u],
Derivative[n][u_] := \[Tau][u] b[u] - \[Kappa][u] t[u],
Derivative[b][u_] := -\[Tau][u] n[u]};

(* here are the rules for how to handle dot products between the *)
(* basis elements and products *)
{b /: Dot[b[u_], Times[a_, f__]] := Dot[b[u], ExpandAll[Times[a, f]]],
b /: Dot[Times[a_, f__], b[u_]] := Dot[ExpandAll[Times[a, f]], b[u]]};
{t /: Dot[t[u_], Times[a_, f__]] := Dot[t[u], ExpandAll[Times[a, f]]],
t /: Dot[Times[a_, f__], t[u_]] := Dot[ExpandAll[Times[a, f]], t[u]]};
{n /: Dot[n[u_], Times[a_, f__]] := Dot[n[u], ExpandAll[Times[a, f]]],
n /: Dot[Times[a_, f__], n[u_]] := Dot[ExpandAll[Times[a, f]], n[u]]};

(* here are the rules for how to handle dot products between the *)
(* basis elements and products of symbols & basis elements *)
(* I'm unclear why I must have these rules and the previous product *)
(* rules --- shouldn't the following rules be sufficient? *)
(* Also, note that I've included the orderless rules for my basis *)
(* elements *)
{b /: Dot[b[u_], Times[a___, b_[u_]]] := a b[u].b[u],
b /: Dot[b[u_], Times[a___, t[u_]]] := a b[u].t[u],
b /: Dot[b[u_], Times[a___, n[u_]]] := a b[u].n[u],
b /: Dot[Times[a___, b[u_]], b[u_]] := a b[u].b[u],
b /: Dot[Times[a___, t[u_]], b[u_]] := a t[u].b[u],
b /: Dot[Times[a___, n[u_]], b[u_]] := a n[u].b[u]};
{t /: Dot[t[u_], Times[a___, b[u_]]] := a t[u].b[u],
t /: Dot[t[u_], Times[a___, t[u_]]] := a t[u].t[u],
t /: Dot[t[u_], Times[a___, n[u_]]] := a t[u].n[u],
t /: Dot[Times[a___, b[u_]], t[u_]] := a b[u].t[u],
t /: Dot[Times[a___, t[u_]], t[u_]] := a t[u].t[u],
t /: Dot[Times[a___, n[u_]], t[u_]] := a n[u].t[u]};
{n /: Dot[n[u_], Times[a___, b[u_]]] := a n[u].b[u],
n /: Dot[n[u_], Times[a___, t[u_]]] := a n[u].t[u],
n /: Dot[n[u_], Times[a___, n[u_]]] := a n[u].n[u],
n /: Dot[Times[a___, b[u_]], n[u_]] := a b[u].n[u],
n /: Dot[Times[a___, t[u_]], n[u_]] := a t[u].n[u],
n /: Dot[Times[a___, n[u_]], n[u_]] := a n[u].n[u]};

(* here are the rules for how to handle dot products between the *)
(* basis elements and sums *)
{b /: Dot[b[u_], Plus[y_, z_]] := b[u].y + b[u].z,
b /: Dot[Plus[y_, z_], b[u_]] := y.b[u] + z.b[u]};
{n /: Dot[n[u_], Plus[y_, z_]] := n[u].y + n[u].z,
n /: Dot[Plus[y_, z_], n[u_]] := y.n[u] + z.n[u]};
{t /: Dot[t[u_], Plus[y_, z_]] := t[u].y + t[u].z,
t /: Dot[Plus[y_, z_], t[u_]] := y.t[u] + z.t[u].z};

--------------------------------------------------------------------
Now here are the results

(* this tests the rules for dot products between products and single *)
(* basis elements *)
In:= (2 \[Tau][x] b[x])) . t[x]
Out:= 0 (* correct *)

(* this tests the rules for dot products between sums and single *)
(* basis elements *)
In:= b[x] . (t[x] - n[x] z \[Tau][x]
+ y (-t[x] \[Kappa][x] + b[x] \[Tau][x] ) )
Out:= y \[Tau][x] (* correct *)

(* this tests the rules for dot products between sums of products *)
(* of the basis elements *)
In:= (t[x] - n[x] z \[Tau][x]
+ y (-t[x] \[Kappa][x] + b[x] \[Tau][x] ) ) .
(t[x] - n[x] z \[Tau][x]
+ y (-t[x] \[Kappa][x] + b[x] \[Tau][x] ) )
Out:= (t[x] - n[x] z \[Tau][x]
+ y (-t[x] \[Kappa][x] + b[x] \[Tau][x] ) ) .
(t[x] - n[x] z \[Tau][x]
+ y (-t[x] \[Kappa][x] + b[x] \[Tau][x] ) )

This is not simplified at all. I believe the problem is that this really
looks like Dot[ Sum[...], Sum[...] ] and I have no rules for dot
products between sums. And I can't since that places b, n, and t too
deep to work for defining upvalues.

So I guess my problem (and question) is what can I implement to teach
Mathematica how to simplify dot products of sums for my basis elements?

```

• Prev by Date: Re: Or in a Select question
• Next by Date: Re: Re: Two questions (1) Sollve and (2) Precision
• Previous by thread: Re: rules for using functions as basis vectors
• Next by thread: Or in a Select question