[Date Index]
[Thread Index]
[Author Index]
Re: mg[14566]: Follow-up on Piecewise Continuous Functions
*To*: mathgroup at smc.vnet.net
*Subject*: [mg14587] Re: mg[14566]: Follow-up on Piecewise Continuous Functions
*From*: Jack Goldberg <jackgold at math.lsa.umich.edu>
*Date*: Mon, 2 Nov 1998 01:50:59 -0500
*Sender*: owner-wri-mathgroup at wolfram.com
Hi Group:
I remarked in my earlier post that manipulating PC functions was not
difficult and I promised to show why and how in subsequent posts.
Here I explain the basic ideas.
(1). Let us agree on a standard form for PC functions. I prefer using
Which[]. Examples:
tent[x_] :=
Which[ -Infinity<x<0, 0, 0<=x<1, x, 1<=x<2, 2-x, 2<=x<Infinity, 0 ]
square[x_] :=
Which[ -Infinity<x<0, 0, 0<=x<1, 1, 1<=x<Infinity, 0 ]
noname[x_] :=
Which[ -Infinity<x<0, x, 0<=x<Infinity, 1 ]
(a) All functions are defined for all x. If necessary we use
"-Infinity < x < a, 0" and "b<= x < Infinity < 0" to insure that
the functions are defined everywhere.
(b) The functions are continuous from the right, that is,
f(a) = Lim f(x), x->a, x>a
(c) In "Which[..., a<=x<b, f(x), ...]" f(x) is assumed to be
analytic in a<x<b. (So f[x] is not itself a piecewise continuous
function.)
Now the question. The function
(A) noname[x] + tent[x]*square[x]
for example, is a PC function. What is its canonical Which form? To
construct the which form for this function, I rely on a new function
called "step". (Not to be confused with UnitStep[] which appears in
many packages but is not built-in at least in Version 3.0 and earlier.)
(2). Defining "step"
step[x_, a_, f_] is not available to the user. It is a function used
only in the private part of the package as an intermediate
computation. It is a numerical function of x, a and f(x) but is
never evaluated. Its meaning is this:
step( x, a, f(x) ) returns 0 if x<a, returns f(x) if x>=a.
Various simplification rules are defined for "step" (as of now I have
9) Here are some samples.
step /: step[ x_,a_,f_ ]*step[ x_, b_, g_ ] := step[ x,Max[a,b], f*g ]
step /: step[ x_,a_,f_ ]^n_Integer?Positive := step[ x,a,f^n ]
step /: step[ x_,a_,f_ ]+step[ x_,a_,g_ ] := step[ x,a,f+g ]
(3). The central idea.
The private function "tostep[]" takes as an argument any combination
of canonical Which[]'s such as the one given in (A) above, and
produces a sum of step functions. The private function "fromstep[]"
converts output of "tostep' to the canonical "Which[]". The rules
that define "step" when used in "tostep" always lead to a sum of this
kind,
step[ x,a1,f1[x] ] + step[ x,a2,f2[x] ] + ... + step[ x,an,fn[x] ]
where a1 < a2 < ... < an. From such sums, "fromstep[]" easily
converts to a single canonical "Which[]". Handling ordinary functions
combined with PC functions is easy, since a separate program writes
f(x) as Which[ -Infinity<x<Infinity,f] or, if necessary,
Which[ -Infinity<x<a, 0, a<=x<b, f(x), b<=x<Infinity, 0 ]
This latter case occurs for functions such as Sqrt[1-x^2] which is
not defined for |x|>1.
The actual implementation of each of these functions (step, tostep,
fromstep, etc) is not difficult but is a bit tiresome. The code
itself is less than 100 lines and has printing and tabulation options
that make for easier visualization. For example, the user function
ToPiecewise[f_,x_,opts]
calls on the private functions to return the canonical PC representation
for any (?) f(x). An optional to ToPiecewise sketches the graph; a
second option writes the PC function in a convenient ColumnForm.
The code will be posted (I hope!) next week.
Jack
Prev by Date:
**Re: More Page Break Problems**
Next by Date:
**RE: Mantain unevaluated**
Previous by thread:
**Re: More Page Break Problems**
Next by thread:
**Mathematica - Which Version To Buy**
| |