Also, at worst you're only off by the mass scaling factor-- you can solve the whole problem as described and the only thing that changes with mass is the speed. Each loop iteration is a time interval, also with some unit that you can select later, where you can rescale the whole problem by the mass and time units. Dimensionally what I've shown is correct, and since you don't actually have a mass or specified time, you can rescale by both later.

The only force component that matters to producing motion is the one that I've called F_perp. The loop is a numerical integration over time to get the position and velocity, where we're using arbitrary time units (which is perfectly acceptable as long as they're consistent). You could explicitly put in a "dt" each iteration, but you can scale by that at any time.

There's nothing philosophical about it--I'm just leaving out the things that don't matter. If there are no torques on the disk/cylinder, then conservation of angular momentum means it will maintain its orientation as it goes round, so that's a distraction. As are forces that put tension or compression on the linkage, but don't produce motion unless you want to include the real properties of materials and then you're talking full up FEM and you might as well just have somebody draw it in SolidWorks and mesh it up to see the tiny deformations (unless you choose silly putty as the material, in which case they'll be huge).

This problem is much closer to my day job than coding in Perl is.

Edits to add more explanation:

I'm not equating a force to a distance-- we're integrating up the acceleration over time. F= ma (units mass*length/time^2). If I divide out the mass (in arbitrary units, where the mass involved =1 unit, then I have a= magnitude(F) with units of (length/time^2). If I calculate the forces on the disk at some time t, then multiply by some small dt (which is buried in the mass scaling factor, so I cheated a little there), then I get a new velocity at time t+dt=v+a*dt, and a new position that's x=x+v*dt. I buried the dt by suggesting that you just keep shrinking the scale til the motions of the linkage on any iteration are small, but you could put it in explicitly for convenience.

Another edit...

since any determination of work done derive from F = ma inevitably requires a known time delta, and there is simply no way to derive one from a static model.

You don't have to ask the static model for a time delta. You pick a time delta small enough that if you calculate the velocity and acceleration (from the net force produced by the static model) at any time t and multiply it by the interval you're choosing, you get a new position and velocity that aren't very different from the previous ones. That's how numerical integration works. As the time delta gets smaller and smaller, you get something closer to what you'd get from an analytical solution.

You are modifying theta by your derived v, but if the force calculated directly opposes or aligns with the current position of link A-B, NO MOVEMENT WOULD RESULT, but your calculation would adjust theta by an effectively random amount.

Simply stated, that cannot be correct; nor even an approximation to correct.

Unless it's already in motion, which it will be if the F_perp is non-zero at some prior time and you haven't by luck gotten to a spot where v=0 and a=0 at the same time.

You need to clarify exactly what you're trying to solve for

At first it sounded like you were looking for the static solution where the forces all add up to zero. If that's the goal, then you can calculate F vs. theta at small intervals all the way around the circle and then pick (or interpolate) the solution where F_perp=0. You can ignore F_parallel-- it will always be balanced by the stiffness of the material (until you break it). If you pick small enough intervals, you shouldn't have to worry about pathological cases of interpolating magnetic fields. They can do goofy things on you, but that will show up as big variations over a small angle in the area you're interpolating. If it's smooth around that region, it's fair to assume it's smooth in the interpolated region.

If you're trying to solve for the dynamic motion of the system by running a static force solver in a loop and integrating (what I described above), then you can write the loop, have it call the magnetic force solver at the prescribed place, decompose it into F_perp and F_parallel, and integrate. If the linkage is already in motion at the point where F_perp=0, then it will drift through that point and start experiencing forces again at some other location. The only time you'll get zero motion is if you get to a time & position where v=0 and F=0. The loop I gave you won't give you a random adjustment at a place where F_perp=0. It will adjust it by the velocity at that time.

As I write this, the heart of the matter seems to be initial conditions-- if you're going to integrate force over time to get position (a perfectly valid thing to do that I do on a regular basis), you have to have some initial position and velocity (zero is a valid choice for both). If you do one time integral of acceleration you get a constant left over, which is the initial velocity. If you do a second time integral, you get another constant, which is the intial position. You haven't been given them, but you have to pick something or you can't do the dynamic solution.

The problem itself is pretty straighforward: you're trying to solve the motion of a rotating system with one degree of freedom (the angle theta), and a variable force (F_perp(theta)), and you're using an external system to calculate the force F(x,y) that you have to convert into F_perp(theta), which I did in my first post. You can ignore everything else, as long as there are no torques on the disk.

EDIT: Here's a revised version of the code that explicitly includes the time interval

$m_inverse=1  /* this could be chosen as arbitrarily small, like 0.000
+01 to get effectively smaller time steps) */
$v=0
$theta=0
$dt=1  /* the time interval, you can also make this of arbitrary size 
+*/
while(!$done){
    ($F_x,$F_y)=ForceCalculator($theta)  /* call your magnetics librar
+y */
    $F_perp=$F_x*sin(theta)+$F_y*cos($theta)
    $theta=$theta+$v*$dt
    $v=$v+$F_perp*$scale*dt
}
[download]

I also swapped the order of the position and time calculation, so that it's using the current velocity v(t_now) to get theta(t_now+dt)=t_now+dt instead of using the velocity(t_now+dt), which shouldn't make much difference if things aren't changing much with position