Newsgroup sci.math.num-analysis 32501

On 22 Jun 1997 21:35:45 GMT, jasonp@Glue.umd.edu (Jason Stratos
Papadopoulos) wrote:
>PS: This is the third time I've had to jump in and clarify what I asked in
>a Usenet post in the last week. Isn't it obvious what I want?
Nope.  [Well, more obvious now, thanks.]  Still wish I could help.
I'll ask about, if you don't get any concrete replies.

: Does not anyone use Pascal's triangle anymore, to compute binomial
: coefficients? You don't ever multiply *any* numbers, you just add; and
: you only encounter overflow when you realio trulio _can't_represent_
: the final answer, not because some intermediate factorial overflowed:
: you never encounter numbers that are unreasonably larger than your
: desired binomial coefficient.
: First you decide how large N will be for your largest (N choose M),
: then you make a table of size (N+1)*(N+1). Initialize the first row to
: be a 1 followed by 0, and the first column all 1. Then fill in by rows
: or by columns: each entry is the sum of the entry immediately above
: and the entry above and to the left:
: 1 0 0 0 0 0 0
: 1 1 0 0 0 0 0
: 1 2 1 0 0 0 0
: 1 3 3 1 0 0 0
: 1 4 6 4 1 0 0
: Then you have a lookup table: look up N along rows, M along columns
: (starting from 0). Thus (4 choose 2) is 6. If you want to use bignums,
: you need never encounter overflow.
Note, however, that what I really *really* want all this mess for involves
a computer program to add up an infinite series in extended precision
(tens of thousands of digits, perhaps even more), and the bottleneck in
computing a term involves computing (2k-1 choose k) cubed. If k is 50,000
a full Pascal triangle is not an option. A *recurrence*, however, will fit
the bill nicely if one can be found. Personally, I'm starting to think the
best way to handle things is to just take the present (2k-1 choose k)^3
and multiply by 8*(2k-1)^3/k^3. It's not impossible or even overly slow,
I was just hoping to do it using only additions.
Thanks for the ideas,
jasonp

>:        On the other hand, Pascal's Triangle is full of
>: interrelationships between the coefficients, and it should be possible
>: to find one which can be used for fairly fast coefficient generation
>: without "greatly" exceeding the final result in any intermediate step.
>: Perhaps a two stage process, with moderately fast techniques used to
>: generate the two coefficients which sum to the answer, and then doing
>: the final addition would be a suitable approach?
>
>This was suggested via email, and looks like it can work nicely. Where can
>I find a rundown of such interrelationships (something more systematic
>than trial and error), and some guidelines for figuring out new ones?
>
>If it'll help, what I want to finally be able to do is compute
>( 2k-1 choose k ) cubed, for k=1,2,3... and possibly very large. The
>"cubed" part complicates things considerably based on my fooling around
>with some recurrences!
>
>Thanks again,
>jasonp
>
	What I have on hand, is "Mathematics for the Analysis of Algorithms" by
Daniel H. Greene and Donald E. Knuth. It opens with a chapter entitled
"Binomial Identities"
	Actually, a more extensive, if concise, source is Vol. 1 of the justly famous
"Art of Computer Programming" by Knuth.
	Knuth also has out a book somewhere in the "Discrete Mathematics for
Computer Scientists" subject area, which is also more extensive in its coverage of
binomial identities. I seem to have the least comprehensive and hardest to find
reference on the topic. Any of the three should serve your needs however.
--------------------------------------------------------------
"I would predict that there are far greater mistakes waiting
to be made by someone with your obvious talent for it."
Orac to Vila. [City at the Edge of the World.]
-----------------------------------------------
R.W. Hutchinson. | rwhutch@nr.infi.net

Hans Olsson  wrote in article
<5oo0nj$4m3$1@news.lth.se>...
[large snip]
> The problem is that this takes a lot of memory, and is furthermore slow.
> Assuming that storing n! takes n log(n) bits (it's approximately true for
> the numbers we are dealing with), and assuming that all elements take
> equal number of bits, we have:
> 
> computing table of n! for 1..n: O(n^2 log(n))
> computing Pascal's triangle for (1..n,1..n): O(n^3 log(n))
> (of course you can use symmetry and some elements require less, but 
> I believe it's something of that order)
> 
> For n=1000 or larger the space requirements seem to be excessive for
> Pascal's triangle.
> 
> Given the relative cost of addition and multiplication it would also be
> a lot faster to precompute the table of n!.
Given a table of factorials, combinations can be calculated with one
multiplication and one division, and permutations with a single division. 
Given a table of factorials (called ldFactorialTable in this example), the
following code will return factorials, combinations, and permutations.  The
code is written for long double, but can easily be adapted for arbitrary
types [much easier in C++ than in C].
{The long double table of factorials is available upon request to those who
would like a copy.  It's about 64K.}
/***************************************************************************
*/
/* Function ldCombinations calculates the combinations of a collection of  
*/
/*  objects taken  at a time.  With combinations, the order of the   
*/
/* objects in the collections has no significance.  Hence, a poker hand    
*/
/* with four aces has the same value regardless of the order in which the  
*/
/* aces were dealt.                                                        
*/
/* ------------------------------------------------------------------------
*/
/* ldCombinations is defined as n!/( r!*( n-r )! ) for the purposes of this
*/
/* program.  While computation of three factorials may seem to be          
*/
/* computationally  expensive, since a table of factorials is readily      
*/
/* available, this is actually a very cheap form of calculation.           
*/
/*                                                                         
*/
/* Requirements:                                                           
*/
/* 1.   Both  and  must be an element of the set [0..MAXFACTORIAL].  
*/
/* 2.   The value of  must be greater than or equal to the value of .
*/
/*                                                                         
*/
/* Returns:                                                                
*/
/* A. Long Double result of calculation ( 10 byte floating point format    
*/
/*    intrinsic to the 80x87 processor or emulated in software ).          
*/
/* B. Error is indicated by return of ( -1 )                               
*/
/***************************************************************************
*/
long double ldCombinations( int n, int r )
{
   long double ldCombinationsAnswer;
   long double ldNumerator;
   long double ldDenominator;
   /* indicate error condition */
   ldCombinationsAnswer = -ldFactorialTable[0];
   /* If all reasonability checks pass, calculate Combinations: */
   if ( n >= r )
      if ( n <= MAXFACTORIAL && n >= 0 )
         if ( r <= MAXFACTORIAL && r >= 0 )
         {
            ldNumerator = ldFactorialTable[n];
            ldDenominator = ldFactorialTable[n-r]*ldFactorialTable[r];
            ldCombinationsAnswer = ldNumerator/ldDenominator;
         }
   return ( ldCombinationsAnswer );
}
/***************************************************************************
*/
/* Function ldPermutations calculates the permutations of a collection of  
*/
/*  objects taken  at a time.  With permutations, the order of the   
*/
/* objects in the collections has significance.  Hence, a DNA strand with  
*/
/* GAA is different than a DNA strand with the sequence AGA or the sequence
*/
/* AAG.                                                                    
*/
/* ------------------------------------------------------------------------
*/
/* ldPermutations is defined as n!/( ( n-r )! ) for the purposes of this   
*/
/* program.  While computation of two factorials may seem to be            
*/
/* computationally  expensive, since a table of factorials is readily      
*/
/* available, this is actually a very cheap form of calculation.           
*/
/*                                                                         
*/
/* Requirements:                                                           
*/
/* 1.   Both  and  must be an element of the set [0..MAXFACTORIAL].  
*/
/* 2.   The value of  must be greater than or equal to the value of .
*/
/*                                                                         
*/
/* Returns:                                                                
*/
/* A. Long Double result of calculation ( 10 byte floating point format    
*/
/*    intrinsic to the 80x87 processor or emulated in software ).          
*/
/* B. Error is indicated by return of ( -1 )                               
*/
/***************************************************************************
*/
long double ldPermutations( int n, int r )
{
   long double ldPermutationsAnswer;
   /* indicate error condition */
   ldPermutationsAnswer = -ldFactorialTable[0];
   /* If all reasonability checks pass, calculate Permutations: */
   if ( n >= r )
      if ( n <= MAXFACTORIAL && n >= 0 )
         if ( r <= MAXFACTORIAL && r >= 0 )
            ldPermutationsAnswer =
ldFactorialTable[n]/ldFactorialTable[n-r];
   return ( ldPermutationsAnswer );
}
/***************************************************************************
*/
/* Function ldFactorial calculates the factorial value of an integer .  
*/
/* This function operates only on integers.  If floating point inputs are  
*/
/* needed, use instead the gamma function.  Since factorials turn up so    
*/
/* often in nature, a precomputed factorial calculation function is really 
*/
/* an essential for the scientist, mathematician, and yes, even the        
*/
/* the businessman.  Double deck pinochle, for instance, requires being    
*/
/* able to calculate 80! for calculation of probabilities.  Mathematical   
*/
/* formulae such as Taylor series expansions, often require the calculation
*/
/* of factorial expressions.  This simple function should lessen the       
*/
/* expense of such calculations.                                           
*/
/* ------------------------------------------------------------------------
*/
/* n! is defined as the product, for ( i=1 to n ) of the integers.  The    
*/
/* exception is 0! which is defined as 1.  Since the factorial function    
*/
/* is really just a subset of the gamma function, as defined for the       
*/
/* natural numbers ( positive integers ) when shifted by one.  As such, it 
*/
/* is quite useful for computation of integral values for gamma.           
*/
/*                                                                         
*/
/* Requirements:                                                           
*/
/* 1.    must be an element of the set [0..MAXFACTORIAL].               
*/
/*                                                                         
*/
/* Returns:                                                                
*/
/* A. Long Double result of calculation ( 10 byte floating point format    
*/
/*    intrinsic to the 80x87 processor or emulated in software ).          
*/
/* B. Error is indicated by return of ( -1 )                               
*/
/***************************************************************************
*/
long double ldFactorial( int n )
{
   long double ldFactorialAnswer;
   /* indicate error condition */
   ldFactorialAnswer = -ldFactorialTable[0];
   /* If the input number n is within range, calculate n! */
   if ( n <= MAXFACTORIAL && n >= 0 )
      ldFactorialAnswer = ldFactorialTable[n];
   return ( ldFactorialAnswer );
}

Wayne Schlitt wrote:
> 
> In <33ad1ba9.941592@news.igs.net> nobody@nowhere.on.ca writes:
> 
> > On 19 Jun 1997 17:40:51 GMT, jasonp@Glue.umd.edu (Jason Stratos
> > Papadopoulos) wrote:
> >
> > >Hello. Is there a way to compute "b choose a" for a and b large, to
> > >full precision [ ... ]
> >
> >                                                            I am trying
> > to fathom how to get "full precision" using an "approximation".
> 
> To get "full IEEE double precision" accuracy, you only need to be
> accurate to one part in 2^54.  You don't need to more exact than that,
> so a good approximation will due.
> 
> -wayne
> 
That completely depends on the question you're asking. If you want to
know the square-free part of the number, then an approximation will help
you nothing. (I think that the square-free part could be calculated
quite a bit faster, by the way)
Nils

In article <5onu2l$17k$1@nw001.infi.net>, rwhutch@nr.infi.net writes:
> 	Knuth also has out a book somewhere in the "Discrete Mathematics for
> Computer Scientists" subject area, which is also more extensive in its coverage of
> binomial identities.
This may be a reference to "Concrete Mathematics" by Graham, Knuth and Patashnik.
-- 
Robert Hill
University Computing Service, Leeds University, England
"Though all my wares be trash, the heart is true."
  - John Dowland, Fine Knacks for Ladies (1600)

What do they say about apples and oranges?
If you use IMSL, you're paying a pretty good fee for a lot of testing,
which presumably assures that you're unlikely to stumble over a bug in the
code.  However, the black box nature of it makes it more likely that
you'll use it incorrectly and find it difficult to understand how.  I've
always worked in organizations which favored code where you could pay
someone else to take responsibility, but we've always ended up replacing
IMSL with our own functions, if only because of the difficulty of keeping
licensing in force over a large network of various brands of computers.
In spite of all the stones being cast at Numerical Recipes, I find it a
step up from the previous situation where we stuck with the oldest
undocumented thing which appeared to work.  At least you have a chance to
form your own opinions about adequacy of documentation, quality of
implementation, etc.
Tim

In article <33AE7D52.1908@hotmail.com>, hasying@hotmail.com writes:
|> Peter Spellucci wrote:
|> > 
|> > what you have is (hopefully) a hyperbolic system of first order,
|> > namely if the matrix
|> >   A    B
|> >   D    C
|> > has two nonzero real eigenvalues. you can solve this system by an
|> > explicit method as you described it. It may however be better
|> > to use the characteristic directions (the eigenvectors of the matrix)
|> > for better reproduction of the true solution.
|> > have a look at introductory texts on this subject.
|> In fact, I try to compare these two methods, which one is better for my
|> problem. Because if I use characteristic method, the value of u(t+1,x)
|> has correlation/depends on the value of v(t+1,x). But if I used FD
|> method, explicit, snip snip
I forgot to warn you concerning explicit FD (as opposed to methods
of characteristics) to use unstable discretizations. E.g. for 
your hyperbolic 2*2 system the methods of Friedrichs and Lax-Wendroff
are both fully explicit and conditionally stable, roughly you must
have
    delta_t/delta_x <= 1/norm(matrix)
these methods are easy to apply and fairly accurate , especially Lax-Wendroff
being second order in delta_t. But if your solution is not very smooth, 
i.e. has a steep gradient somewhere, then you will get trouble with FD-resolution,
since your FD-grid will not be able to reproduce this correctly. Then you
will get a wriggled output, and maybe a customer of your program will be quite
unhappy concerning the result. Don't forget that there are naive unstable 
FD-formulas,  
e.g.
 W_{n+1,i} = W_{n,i} + delta_t/(2*delta_x) AA ( W_{n,i+1}-W_{n,i-1} )
with W=(u,v)  and  AA the matrix from above n=grid number in time, i=grid number
in space, is unstable and hence nonconvergent. 
hope this helps
peter

 1)  There are many reports of the inadequacies of the NR code.  
 2)  IMSL may be expensive, but it is very rare to find a bug in it.
 3) However, there's no reason in the world to pay for the sorts of routines you
  find in IMSL.  There are many freely available packages at http://www.netlib.org/,
  most  of which (blas, lapack, routines from TOMS, ...) are extensively debugged
    and very reliable.  I don't think there is anything in IMSL that you can't find at 
   netlib.

In article <5ol8j5$mt3$1@news.tudelft.nl>, D.P.Tran@et.tudelft.nl (Diane) wrote:
> (F(1)= (0.80951, 0.23219)) and this is not equal to the 
> tabulated fx[] =(0.8095, 0.1322) ? How can I fix this ? 
Improve the accuracy of the precomputed fxx by replacing
  complex( .2187,-.0757)
by
  complex (.2186666666, -.075666666666)
Similarly, for 5.5, improve the accuracy of
  complex (.0093, -.0163)
to
  complex(.00926666666, -0.1633333333)
This second case is tricky because one would expect that the interpolation
for 5.5 would take into account xx[7]=5.5 instead of xx[6]=4... but in fact
although x looks like 5.5 when printed, it is obtained by repeated addition
of 0.1 to lower=0.2 in main, and by roundoff error this turns out very
slightly smaller than 5.5, which explains the use of the [4,5.5] interval
for interpolation.
Note also that there's an error in the original program's statements
  for (int n = 0; n <= 7; n = n + 1)
      {
        if (x >= xx[n] && x < xx[n + 1]) etc.
since this will refer to an inexistant xx[8] if x=5.5 exactly, and may or
may not work depending on the value of that memory location xx[8], which is
outside the array xx.
Quick solution (kludgy): add an extra value to xx, larger than 5.5, like 6,
and (for safety) an extra value to fxx, e.g. zero, so fxx[8] is defined and
not, e.g. NaN by coincidence. Then for x=5.5 (exactly) F will be computed
as
F = fxx[8] * (x - xx[7]) + fx[7]
    ^ zero    ^ zero       ^ the value
>        When I put lower=0.2 upper=(2.3/ 2.4/ 2.5 ....)
> Why does the program print ONLY up to FTF(upper-increment)
> and the last value FTF(upper) is not printed,
This is due to floating-point roundoff error. It is preferable to use
integers as loop counters instead, then you're sure that the number of
iterations will be right.
--
Dr. Denis Constales - dcons@world.std.com - http://cage.rug.ac.be/~dc/

                             CALL FOR PARTICIPATION
                                   SCAN-97
            GAMM/IMACS International Symposium on Scientific Computing,
                  Computer Arithmetic and Validated Numerics
                            September 10-12, 1997
                    Ecole Normale Superieure de Lyon France
                       http://www.ens-lyon.fr/LIP/SCAN-97/
The conference continues the series of SCAN-Symposia which have
previously been held at Karlsruhe, Basel, Albena, Oldenburg, Vienna and
Wuppertal under the joint sponsorship of GAMM and IMACS. These
conferences have traditionally covered the numerical and algorithmic
aspects of Scientific Computing, with a strong emphasis on the
algorithmic validation of results and on algorithmic and arithmetic
tools for this purpose.
SCAN-97 will provide a forum for presentation of the latest research
and developments in theory, algorithmic and arithmetic design for
Validated Numerics; demonstration of new software available for
Validated Numerics; reports of interesting case studies in industrial
and scientific application of Validated Numerics; and discussion of new
directions in research and development suggested by other advances  in
Scientific Computing. Potential new directions are the use of parallel
architectures for the implementation of validation algorithms and the
use of validation ideas in Computer Algebra.
More information (including scientific committee, proceedings,
transportation and accommodation) can be found in our web page:
www.ens-lyon.fr/LIP/SCAN-97
PRELIMINARY PROGRAMME
**********************************************************
 Wednesday September 10
**********************************************************
08h30-09h30 Opening session
09h30-10h30 Plenary Talk :  Wolfgang Walter (Univ. Dresden, Germany), On the Suitability 
of Programming Language Concepts for Reliable Floating-Point Computation.
10h30-11h30 Plenary Talk : Svetoslav Markov (Bulgarian Academy of Sciences)
11h30-12h00 Break
12h00-13h30 Parallel sessions
- Session 1 "Programming languages"
Genesio Gomes da Cruz Neto, Rafael Dueire Lins, Marcia de Barros
Correia, Genaro Dueire Lins and Gustavo Fraidenraich, Programming
Interval Algorithms in Haskell
Raul Trejo, A Functional Language for Interval Arithmetic,
Jurgen Wolff v. Gudenberg, Java for Scientific Computing, Pros and Cons
- Session 2 "Probabilistic analysis"
Roberto Barrio and Jean-Claude Berges, Perturbation simulations of
rounding errors in Chebyshev series
Marcilia A. Campos, Validating Probabilities for the Random
Variables Binomial and Poisson
 J.M. Chesneaux and F. Jezeequel, Dynamical numerical validation of
quadrature methods
14h30-16h30 Parallel sessions
- Session 3 "Packages"
Rafael Linden Sagula and Tiaraju Asmuz Diverio, Interval Software
Performance
Ursula Lisboa Fernandes and Tiaraju Asmuz Diverio, High accuracy 
arithmetic kernel of libavi.a interval library
Frantisek Mraz, Pascal Software for Calculating the Exact Bounds of
Optimal Values in Interval LP
Zyuzin V. S., Rychkova N. A., Interval splines finding for the
solution of ODE systems with the help of Taylor series. Their
realization at Pascal XSC
- Session 4 "Theoretical results"
Gerhard Heindl, Optimal inclusions of integrals from inclusions of
function values and slopes
A. T. Popov, On some relations between morphological and interval
operations.
Evgenija D. Popova and Svetoslav M. Markov, Algebraic Solution to
Some Interval Equations
Paulo Werlang de Oliveira and Dalcidio Moraes Claudio, A Formal
Extension for the Set IR
16h30-17h00 break
17h00-19h00 Parallel sessions
- Session 5 "Optimization and Approximation 1"
Roumen Anguelov, Spline-Fourier Approximations of Discontinuous Waves
Andras Erik Csallner, Tibor Csendes, Mihaly Csaba Markot,
Convergence Properties for Multisplitting Interval Methods for Global
Optimization
Andras Erik Csallner, Tibor Csendes, Mihaly Csaba Markot,
Multisection in Interval Methods for Global Optimization
Laurent Granvilliers, A Symbolic-Numeric Framework for Solving Real
Constraints
- Session 6 "PDE and ODE 1"
R. Aid, L. Testard and G. Villard, Global Error Visualization 
Eduardo Gallestey, Spectral Value Sets of the Orr-Sommerfeld Operator
F. Hoshino, M. Sugihara and S. Fujino,A numerical method for the
exact solution of Burger's equation using overload function of C++
Mitsuhiro T. Nakao and Cheon Seoung Ryoo, Numerical verifications
of solutions for variational inequalities
*****************************************************************
Tuesday September 11
*****************************************************************
09h30-10h30 Plenary talk: Bruno Lang (Wuppertal Univ., Germany)
10h30-11h30 Plenary Talk: Walter Kraemer (Karlsruhe Univ., Germany),
 "Constructive Error Analysis".
11h30-12h00 break
12h00-13h30 Parallel sessions
- Session 7 "non linear systems"
Yuchi Kanzawa and Shin'ichi Oishi, Approximate Singular Solutions
of Nonlinear Equations and a Numerical Method of Proving their
Existence
Yusuke Nakaya and Shin'ichi Oishi, Finding All Solutions of
Nonlinear Systems of Equations Using Linear Programming with Guaranteed
Accuracy
Yusuke Nakaya and Shin'ichi Oishi, Mathematical Programming Based
Rigorous Numerical Nonexistence Test for Solutions of Nonlinear
Equations
- Session 8 "Architectures for reliable computing 1"
Hesham A. Al-twaijry, Stuart F. Oberman, Steve T. Fu and Michael J.
Flynn, The SNAP Projet : Building Validated Floating Point Units
V. Coissard and A. Guyot, OCAPI : A coprocessor for infinite
precision arithmetic
Samir Tagzout and Leila Sahli, Compact Multipliers Using the
Sign-Generate Method in FPGA
14h30-16h30 Parallel sessions
- Session 9  "Optimization and Approximation 2"
Frederic Messine and Jean-Louis Lagouanelle, A Global Optimization
Algorithm for Multivariate Differentiable Functions
V.A. Perepelitsa and G.L. Kozina, Making decision in discrete interval 
optimization problems
Knut Petras, On the speed of self-validating algorithms for
approximation or integration of singular functions
Shen Zuhe and Huang Zhenyu, Interval maximum entropy methods for
minimax problems
- Session 10 "PDE and ODE 2"
M. Neher, Enclosing solutions of an inverse Sturm-Liouville problem
for an impedance
Robert Rihm, Implicit Methods for Enclosing Solutions of ODEs
Rogalev Alexey N., The interval method for ordinary differential
equations and shift along trajectories
Takao Soma, Shin'ichi Oishi and Kazuo Horiuchi, An Iterative
Refinnement Method for Solutions of Nonlinear Ordinary Differential
Equations with Arbitrary Precision
16h30-17h00 break
17h00-19h30 Parallel sessions 
- Session 11 "Linear algebra"
Olivier Beaumont and Bernard Philippe, An Iterative Algorithm for
Interval Eigenvalue Problem
Anatoly V. Lakeysev, On Systems of Linear Interval Equations Having
a Finite Set of Solutions
G. Rex, Componentwise Distance to Singularity
Jiri Rohn, P-matrices and regularity: a survey
Sergey P. Shary, On Uniqueness of the Algebraic Solutions to
Interval Linear Equations
- Session 12 "Computer Arithmetic"
Wolfram Luther and Werner Otten, Reliable computation of elliptic
functions
Vyacheslav M. Nesterov, On accuracy of estimation in twin arithmetic
Asger Munk Nielsen and Peter Kornerup, Generalized Base and Digit
Set Conversion
Mitsuo Ooyama and H. Hamada, Fast Separation and Combination of an Exponent and a
Fraction for URR Floating-Point Arithmetic
Guoheng Wei and David W. Matula, Realizing Accurate and Efficient
Reciprocal Functions by Interpolation
*****************************************************************
Friday September 12
*****************************************************************
09h30-10h30 Plenary session: Jean-Daniel Boissonnat (INRIA Nice, France)
10h30-11h00 break
11h00-13h30 Parallel sessions
- Session 13 "Geometry"
Bronnimann and Pion, Exact rounding for geometric functions
Karl-Udo Jahn, Computing the convex hull of sets of rectangles in
the plane
Yu. G. Stoyan, Interval Analysis Application in Geometry
Fabiana Zamora Wilke, Beatriz Regina Tavares Franciosi, Paulo
Werlang Oliveira and Dalcidio Moraes Claudio, Modelling of the Measures
Uncertainty by Intervals
- Session 14 "Chaos and dynamical systems"
Farit M. Akhmedjanov and Victor G. Krymsky, Frequency
domain technique application to interval dynamic system analysis,
Zbigniew Galias, Numerical studies of the Henon map
Shin'ichi Oishi, Numerical Verification Method of Existence of
Connecting Orbits for Continuous Dynamical Systems
Klaudiusz Wojcik, Algorithms for constructing isolating blocks. A
geometric method for detecting chaotic dynamics.
Piotr Zgliczynski, Algorithm for finding TS-map structure
14h30-15h30 Parallel sessions
- Session 15 "Architectures for reliable computing 2"
Vladimir Tarasenko and Oleksandr Shcherbyna, the using of symmetric
property of the computed functions in the table computer arithmetic.
 J.M. Tourreilles, C. Nouet and E. Martin, Digital signal processor
implementation under computation signal to noise ratio
- Session 16 "Parallel algorithms"
Oliver Bergmann and Andreas Frommer, Parallelization of enclosure
methods for zeros of nonlinear functions
Sonja Berner, Ken McKinnon and Colin Millar, A Parallel Algorithm
for the Minimization of Gibbs Free Energy
15h30-16h00 break
- 16h00-18h00 Parallel sessions
- Section 17 "Miscellaneous 1"
Jurgen Garloff and Birgit Graf, Robust Schur Stability of
Polynomials with Polynomial Parameter Dependency
Maria Angelica de Oliveira Camargo Brunetto, Algebraic Algorithms
For Enumerating Polynomial Zeros In A Disk : How To Choose The Suitable
Algorithm
Vitaly Telerman, Merging Constraint Programming Technology with
Interval Computations
Nikolay M. Vasilega and Anna V. Nelasa Zaporozhye, Application of
hystogramme arithmetics for prediction of fatigue failures
- Session 18 "Miscellaneous 2"
Stanislaw Bialas and Wieslaw Solak, A Remark on Power Series
Estimation via Boundary Corrections
Oleg B. Ermakov, Guaranteed outer and inner inclusions of fixed
points of a Volterra Integral operator in interval spaces.
Czeslaw Koscielny, A Validated Software Method of Computing Minimal
Polynominals for Elements of Large GF (2m)
Gregory G. Men'shikov, Interval Realizations of Interpolational
Quadrature Remainder
                                     SCAN-97
            GAMM/IMACS International Symposium on Scientific Computing,
                  Computer Arithmetic and Validated Numerics
                            September 10-12, 1997
                    Ecole Normale Superieure de Lyon France
                                REGISTRATION FORM
The conference fee covers the conference materials (the final program,
a booklet containing all abstracts, general information, etc.),
services of the conference office, refreshments during the morning and
afternoon breaks and daily lunches.
To avoid excessive bank charges for the cashing of foreign cheques, we
only accept:
- BEFORE the conference: payment by credit cards (VISA or MASTERCARD), or 
cheques  in french francs drawn on french banks, or order forms ("bons de commande")
 from a french company or university.
- DURING the conference: payment by cash (please, no credit cards), or cheques  
in french francs drawn on french banks, or order forms ("bons de commande") from 
a french company or university.
If you use a credit card, please don't send your card number through
the Internet: hand-write your credit-card information on a printed copy
of this form, sign the page, and send it to our address (see below).
For people from eastern countries who applied for a grant: register
now, but do not pay de fee before we have an answer about the grant. If
you don't get the grant and come anyway, you will only pay the early
registration price, even after July 15.
IMPORTANT: You can register using our html page:
http://www.ens-lyon.fr/LIP/SCAN-97/
Conference fees (in French Francs, all taxes included):
                     Early registration           Late registration
                     Before July 15               After July 15
 Students               650 F                          750 F
 Imacs members          850 F                          950 F
 Others                 900 F                         1000 F
Name:
Institution:
Christian name:
Address:
Phone:
Fax:
e-mail address:
What do you want to see printed on your badge:
( ) please find enclosed a cheque in french francs, drawn on a french bank,
of an amount of ..., payable to "Monsieur l'Agent Comptable de l'ENS Lyon"
( ) please find enclosed an order form from a french university 
of an amount of ..., payable to "Monsieur l'Agent Comptable de l'ENS Lyon"
( ) please charge my credit card
              - amount
              - type (Visa or Master Card)
              - number
              - expiration date
              - signature
( ) I will pay on-site (late registration fee)
( ) I have applied for a grant
Send this form to
     SCAN-97, Laboratoire LIP, ENS Lyon
     46 Allee d'Italie, 69364 Lyon Cedex 07 France
     Fax +33 4 72 72 80 80 (attn SCAN-97, LIP)
(e-mail scan97@ens-lyon.fr)
-- 
---------------------------------------------------------------------
Jean-Michel Muller, CNRS, Lab. LIP, Ecole Normale Superieure de Lyon
46 Allee d'Italie, 69364 Lyon Cedex 07, FRANCE.  
Tel. +33 4 72 72 82 29   Fax. +33 4 72 72 80 80 from abroad
        04 72 72 82 29           04 72 72 80 80 from France
http://www.ens-lyon.fr/~jmmuller  email: jmmuller@ens-lyon.fr

Mira esto, no somos los �nicos.
 Paco Oca�aStefan Nonneman  wrote:
>Hi,
>
>I want to calculate the eigenvalue/eigenvector pairs of a 20x20
>non-symetric real matrix using the eigenvalue related routines
>BALANC, ORTHES, ORTRAN, HQR2, ORTBAK and BALBAK from EISPACK.
>The strange point is that I can calculate the right eigenvalues and
>eigenvectors but only 12 of the 20 are correct pairs. The remaining
>8 eigenvectors are paired with the wrong eigenvalues.
>
>Is there someone who already used the eispack routines with good result 
>who can give me some hints in order to solve the problem.
>
>PS : I checked the values against the ones produced by matlab.
>The matlab function EIG is an implementation of the above mentioned
>routines ( But I find different results ).
>
>Thanks in advance,
>
>Stefan Nonneman

adfldjs@lkasjdfdsal.com wrote:
> 
> Looking for Dirty Schoolgirls...
Yup, good old adfldjs is posting in the right place...
			Randy

In article <5okq5j$c6b$3@berlin.infomatch.com> haasj@infomatch.com (Jarrod Haas) writes:
>I'm writing a raw data manipulation utility for POV and I've encountered a 
>problem: I have no idea how to calculate surface normals! 
>The algorithm I tried looks like this where vertex b and c are the other
>points of the triangle: 
>
>void Vertex::Calc_normal(Vertex b, Vertex c)
>{
>
>  nx = y*(b.z - c.z) + b.y*(c.z - z) + c.y*(z - b.z);
>
>  ny = z*(b.x - c.x) + b.x*(c.x - x) + c.z*(x - b.x);
>
>  nz = x*(b.y - c.y) + b.x*(c.y - y) + c.x*(y - b.y);
>
>}
i assume that the instance of vertex has its coors in x,y,z:
try
void Vertex::Calc_normal(Vertex b, Vertex c)
{
  nx = (b.y-y)*(c.z-z) - (b.z-z)*(c.y-y);
  ny = (b.z-z)*(c.x-x) - (b.x-x)*(c.z-z);
  nz = (b.x-x)*(c.y-y) - (b.y-y)*(c.x-x);
}
of course you have to divide it by its own length to normalize
it, but that should be trivial enough.
>But it doesnt work properly. I would appreciate any source code examples (c or
>otherwise), none code examples, discussion, or locations that have information
>on this subject.
Any book about analytic geometry, under 'properties of cross products',
esp. ((a x b) , a) = ((a x b) , b) = 0
-- 
--
Ernst-Udo Wallenborn
Laboratorium fuer Physikalische Chemie
ETH Zuerich