Mathematica 9 is now available
Services & Resources / Wolfram Forums
-----
 /
MathGroup Archive
1996
*January
*February
*March
*April
*May
*June
*July
*August
*September
*October
*November
*December
*Archive Index
*Ask about this page
*Print this page
*Give us feedback
*Sign up for the Wolfram Insider

MathGroup Archive 1996

[Date Index] [Thread Index] [Author Index]

Search the Archive

Re: Re: programming competition

  • To: mathgroup at smc.vnet.net
  • Subject: [mg4904] Re: [mg4866] Re: programming competition
  • From: Allan Hayes <hay at haystack.demon.co.uk>
  • Date: Fri, 4 Oct 1996 00:17:40 -0400
  • Sender: owner-wri-mathgroup at wolfram.com

rhall2 at umbc.edu (hall robert)
[mg4866] Re: programming competition

Bob, considers Xah Lee's problem (at [1] below), and introduces a  
solution (at[2]) with the remark

>With Lichtblau's and Hayes' admonitions to use procedural  
>programming to solve procedural problems ringing freshly in my  
ears, >I offer the following:

Still, my preference is definitely for functional and list  
processing styles and I strongly recommend them (see Experiments in  
Efficient Programming, The Mathematica Journal, 5, No 1, 24-31,  
1995.).

Here is another solution to Xah's problem

linearInterpolate2[ li_List, m_ ] :=
   Block[{n},
      Append[
         Join@@Partition[ li, 2,1,
	    (  n=Floor[Sqrt[(#2-#1).(#2-#1)//N]/m];
	       If[n<2, {#1},
		    Table[#1 + k #2, {k,0,n}]&[#1,(#2-#1)/(n+1)]
	       ]
	    )&
	  ],
	  Last[li]
      ]
   ];

(*check*)

linearInterpolate2[{{0, 0}, {1, 1}, {1, 1}, {6/5, 1}, {7/5, 1},
   {8/5, 1}, {9/5, 1}, {2, 1}, {2, 1}, {3, 3}},  .3
]

  {{0, 0}, {0.2, 0.2}, {0.4, 0.4}, {0.6, 0.6}, {0.8, 0.8}, {1., 1.}, 
   {1., 1.}, {1.2, 1.}, {1.4, 1.}, {1.6, 1.}, {1.8, 1.}, {2., 1.},
  {2., 1.}, {2.125, 1.25}, {2.25, 1.5}, {2.375, 1.75}, {2.5, 2.},
  {2.625, 2.25}, {2.75, 2.5}, {2.875, 2.75}, {3, 3}}


(*timings*)

li2 = Table[Random[], {1000},{2}];

linearInterpolate2[ li2, .3 ];//Timing
	{6.91667 Second, Null}

insertPoints[ li2, .3 ];//Timing	(*Robert Hall*)
	{9.66667 Second, Null}


Allan Hayes
hay at haystack.demon.co.uk

*************************************************

[1] Problem
Suppose you have a ordered list {p1, p2, ... , pn} where points has  
the form {x,y}. You want to modify the list so any neighboring  
points will have a distance less or equal to a given value  
maxLength. You do this by adding points in between points. For  
example, suppose p3 and p4 has length greater than maxLength. Your  
new list should then be
{p1, p2, p3, newP1, newP2,..., newPm, p4, p5, ... , pn} where
newP1, ...newPm lies on the line p3 p4.



[2] Robert Hall's solution

   insertPoints[points_List, maxDistance_] := Module[
      {vector, distance},
	
      Append[
         Flatten[	
            Table[
               If[
                  vector =
                     points[[pointIndex]] -
                     points[[pointIndex + 1]]
                  ;
                  distance = N[Sqrt[vector . vector]];
			
                  distance > maxDistance,
                  (points[[pointIndex]] - #)& /@ Table[
                     multiplier * vector / distance,
                     {
                        multiplier,
                        0,
                        distance,
                        maxDistance
                     }
                  ],
                  {points[[pointIndex]]}
               ],
               {pointIndex, Length[points] - 1}
            ],
            1
         ],
         Last[points]
      ]
   ]

==== [MESSAGE SEPARATOR] ====


  • Prev by Date: Re: programming competition
  • Next by Date: InterpolatingFunction
  • Previous by thread: Re: programming competition
  • Next by thread: Re: optimal control