Or often you can avoid using angles entirely and use mechanisms based
on cross product for contexts that demand "sine" and dot product for
cosine...
(Not always, though - especially if you're working through someone
else's math notes which were explicitly about angles.)
Thanks,
--
Raul
On Tue, Mar 26, 2019 at 3:16 PM William Tanksley, Jr
<wtanksle...@gmail.com> wrote:
>
> Does J provide rational trig functions? If not, you'll want to check
> out N.J. Wildberger's rational trigonometry, based on "quadrance" (an
> unsquare-rooted distance) and "spread" (like a relative slope of
> quadrances). That way your rational numbers will stay rational until
> it's time to convert them to display values.
>
> -Wm
>
> On Tue, Mar 26, 2019 at 12:12 PM Raul Miller <rauldmil...@gmail.com> wrote:
> >
> > The x: verb makes a best effort, converting floating point to rational.
> >
> > x:3.14
> > 157r50
> >
> > It's limited, of course, by both floating point precision and its own
> > internal concepts of epsilon.
> >
> > I hope this helps,
> >
> > --
> > Raul
> >
> > On Tue, Mar 26, 2019 at 3:08 PM Ian Clark <earthspo...@gmail.com> wrote:
> > >
> > > I'm doing trigonometry with very small angles and I want to keep all my
> > > calculations in rational precision. Is there a J-supported way of
> > > converting from floating-point precision to rational, or reasonably speedy
> > > verbs to do the job routinely?
> > >
> > > My problem is this. Let PIa be π expressed as a rational number to 50
> > > places of decimals (…or more!!)
> > >
> > > PIa
> > > 31415926535897932384626433832795028841971693993751r10000000000000000000000000000000000000000000000000
> > > datatype PIa
> > > rational
> > > datatype y=: 1.23
> > > floating
> > > datatype PIa + y NB. loses precision...
> > > floating
> > > datatype sin PIa NB. likewise loses precision...
> > > floating
> > >
> > > In other words, adding in (or otherwise combining) a number (y) which is
> > > defined *exactly* as a decimal numeral (the sort of thing the SI system of
> > > units does often) results in an avoidable loss of precision.
> > >
> > > (In case anyone's thinking at this point: aren't 64 bits good enough for
> > > this guy? -- no, they aren't.)
> > >
> > > At present I'm using a mickey-mouse scheme of converting the decimal
> > > numeral (":1.23) to a rational value by omitting the decimal point to get
> > > '123', then reintroducing it as a denominator: '123r100' -- which I then
> > > evaluate using (".) to give, in effect:
> > > datatype ya=: 123r100
> > > rational
> > > datatype PIa + ya NB. --now it behaves itself...
> > > rational
> > >
> > > And of course I'm going to have to write my own sin and cosine verbs.
> > >
> > > The general purpose engine I'm writing not only needs a way of converting
> > > an inputted numeral '1.23' to a rational number (a trivial task by the
> > > above method) but also to check my results accumulator at every step to
> > > stop it lapsing into floating-point precision, and maybe to convert it
> > > back
> > > into rational precision.
> > >
> > > This last task is inefficient, the way I'm doing it. Does J have a
> > > built-in
> > > way, or a standard way, that's faster than how I'm doing it?
> > >
> > > Ian Clark
> > > ----------------------------------------------------------------------
> > > For information about J forums see http://www.jsoftware.com/forums.htm
> > ----------------------------------------------------------------------
> > For information about J forums see http://www.jsoftware.com/forums.htm
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
