Move detectEdge to the @fun level.
Enabling edge detection for blowing up functions.
Restoring the modification for the function handle in the presence of singularities.
Prevent edge detection at infinity.
Minor.
Merge branch 'development' into fix-detectEdge

Conflicts:
	tests/chebop/test_nonlinearSystemDampingBreakpoints.m
Properly passing the exponents in test for bndfun constructor.
Tweaking a test in unbndfun/test_sum.m
Normalizing EIGfuns returned so that they're always positive
at an arbitrary point just right to the midpoint of the domain.
Cosmetic changes.
Clean up get() functions in interior classes.

This is progress towards resolving #533.  If an internal get() function
doesn't know how to respond to a property request, it passes it on to
the next layer down.  If the bottom-most layer can't handle it, then its
get() method issues an error.
Clean up the chebfun get() method.

Lots of changes here.  Normally, I'd break this thing up into separate
commits, but these sort of all happened at once and don't easily split
apart from one another.

  1.  Just about everything has been refactored.  The get() calls for
  many properties are now handled through some subfunctions instead of
  being coded inline.  Unfortunately, the logic in these functions can get
  kind of complicated and hard to follow.  There are two sources of
  complexity here:

    A.  We need to ensure that get(f, prop), where f is an array-valued
    chebfun gives the same results as it would if f is a quasimatrix.
    Moreover, we need to do this without just converting every array-valued
    chebfun input into a quasimatrix, which would be too expensive.

    B.  We need to try and return "simpler" outputs if possible, e.g., a
    numeric matrix instead of a cell array of cell arrays of values.

  2.  With everything rewritten from scratch, several bugs in get()
  which had it acting differently for array-valued chebfuns and
  quasimatrices have been fixed.

  3.  Instead of returning a 2D cell arrays with empty cells, get(f,
  prop), where f is a quasimatrix whose columns have differing number of
  funs, returns a cell array of cell arrays C such that C{J}{K} gives
  the value of the property for fun K in column J.  C{J} has only as
  many cells as there are funs in column K.

  4.  chebfun.get() is now set up to potentially allow you to get()
  arbitrary properties from the funs, e.g., if your tech supports property
  foo, you could do get(f, 'foo') to get a cell array of cell arrays as in
  the previous paragraph.  I have not activated this capability yet; for
  the moment, we still issue an error if the input property is not
  recognized.  But in principle, it should now be quite easy to activate.

  5.  In conjunction with the previous commit, this commit eliminates
  get(f, 'deltafunctions') and get(f, 'deltafuns').  get(f, 'deltas') is
  always more convenient to use than these, and we aren't constrained by
  backwards compatibility to keep the other syntaxes, so let's not bind
  ourselves in the future by introducing them now.

  6.  The behavior of get(f, 'deltas') is different for array-valued
  chebfuns and quasimatrices.  Previously, get(f, 'deltas') would return a
  2D cell array with the J-K entry containing the value of the 'deltas'
  property for fun J of column K.  Now it returns a one-dimensional cell
  array whose K'th entry contains the output of get(f(:, K), 'deltas').
  The local 'deltas' properties can now be gotten through get(f,
  'deltas-local').

The only parts of the non-get() code that needed to be altered to
accommodate these changes were a few places where the code ended up
relying on the difference in behavior of get() for array-valued chebfuns
and quasimatrices.  All chebfun tests pass for me at the moment.

This method is now sufficiently complex that it warrants a test.  I'll
do this if others think that the changes made here are worth keeping.

We may want to consider exposing the doSimplify flag used by some of the
functions to the user:  the simplification tricks are convenient when
messaing around at the command prompt but are much more irritating if
you're trying to write a routine that accepts general inputs.
Changing the definition of sinc()

In v4 we used sinc(x) = sin(x)/x. In v5 we used
sinc(x) = sin(pi*x)/(pi*x).

Switching it to v4 definition of sinc(). This was
causing an example to break.
Merge branch 'development' into fix-normalize-eig
Cosmetic changes.
Cosmetic changes.
Add input to chebfun.get() for controlling output simplification.

As remarked in the help text, this is helpful for programmers, who generally
want the output to be as uniform as possible to make it easy to process without
requiring complicated logic.  The simplified versions are of more use to users
working in the command window, where unpacking cell arrays can be more
inconvenient.

This commit also greatly expands the documentation to spell out the exact rules
governing how things are simplified.
Merge branch 'development' of ssh://github.com/chebfun/chebfun into fix-normalize-eig
Merge branch 'fix-chebmatrix-scalar-mult' into fix-normalize-eig
Modify ODE codes to work with new get().

The code which uses the outputs of these calls expects 2D cell array outputs in
situations in which get() will try to simplify them further.  So, we force
get() to return 2D cell arrays by setting the simplification level to 1.

With these changes, all existing tests pass on my machine.