juliamath / tau.jl Goto Github PK

View Code? Open in Web Editor NEW

36.0 6.0 9.0 67 KB

A Julia module providing the definition of the circle constant Tau (2π)

License: Other

Julia 100.00%

tau julia math mathematics trigonometry number circle constant

tau.jl's Introduction

Tau.jl

This Julia package defines the Tau constant and related functions.

tau ≈ 2*pi

Usage

After installing this package with Pkg.add("Tau"), it can be used as follows:

julia> using Tau

julia> tau === τ ≈ 2*pi
true

julia> typeof(tau)
IrrationalConstants.Twoπ

Note: to input the τ character, type \tau then press Tab.

The tau variants of sinpi, cospi, sincospi, cispi, and mod2pi are also defined:

julia> sintau(1//4)
1.0

julia> costau(1//2)
-1.0

julia> sincostau(1//2)
(0.0, -1.0)

julia> cistau(1//2)
-1.0 + 0.0im

julia> modtau(9*pi/4)
0.7853981633974481

Alternatively, one can use the Unicode aliases sinτ, cosτ, sincosτ, cisτ, and modτ.

The tau != 2pi inequality

When this package was first created, the equality tau == 2pi did hold true, in accordance to the mathematical definition of the constant. However, that is not valid anymore -- the two values are only approximately equal: tau ≈ 2*pi.

For a detailed explanation of the reasons for this, see this document.

tau.jl's People

Contributors

Stargazers

Watchers

Forkers

kmsquire tkelman juliatagbot standardgalactic wookay hyrodium ranocha

tau.jl's Issues

trig functions are not type-stable for complex inputs

Came across this while working to improve test coverage:

julia> show(Base.return_types(sintau, Tuple{Complex}))
Any[Any]

julia> show(Base.return_types(costau, Tuple{Complex}))
Any[Any]

julia> show(Base.return_types(modtau, Tuple{Complex}))
Any[Any]

Create a script to help conversion of 2pi

From issue #22:

[Automatically converting 2pi to tau could actually be] counterproductive to the "tauist cause": if one chooses to use the Tau package, it would make sense for them to take the extra step to change their code to explicitly reflect their choice of circle constant, rather than leaving the 2pi's around.

With that in mind, though, I think it would be nice to provide some sort of warning for when a downstream package uses 2pi in its code -- which could be done by overriding *(2, pi), without changing its resulting type. I'm not sure if it's possible to distinguish code from a module from code from modules it imports (we wouldn't want to warn a user of instances of 2pi in packages they didn't author);

If that distinction is not possible (or the warning approach found too intrusive), then an alternative could be a helper script or method in this package that would process a given module or file and output a list of locations where 2pi could be replaced by tau. This is easy enough to do by hand, but depending on the search method, one could easily miss valid instances -- 2pi, 2*pi, 2 * pi, 2.0 * pi, pi*2, etc. -- so an automated process might be useful.

To which @giordano replied:

I don't have a strong opinion on this. In any case, I wouldn't make it part of the package itself, at least an extra script to be placed outside src directory.

So this issue it to track the implementation of such a script.

Missing `sincostau`

sincospi was introduced in JuliaLang/julia#35816, so it seems better to add sincostau method in Tau.jl

TagBot trigger issue

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

Add examples

It would be nice to have an examples directory with common functions written using tau.

Package compatibility caps

Ref: https://discourse.julialang.org/t/package-compatibility-caps/15301

[PkgEval] Tau may have a testing issue on Julia 0.2 (2014-07-08)

PackageEvaluator.jl is a script that runs nightly. It attempts to load all Julia packages and run their tests (if available) on both the stable version of Julia (0.2) and the nightly build of the unstable version (0.3). The results of this script are used to generate a package listing enhanced with testing results.

On Julia 0.2

On 2014-07-07 the testing status was Tests pass.
On 2014-07-08 the testing status changed to Tests fail, but package loads.

Tests pass. means that PackageEvaluator found the tests for your package, executed them, and they all passed.

Tests fail, but package loads. means that PackageEvaluator found the tests for your package, executed them, and they didn't pass. However, trying to load your package with using worked.

This issue was filed because your testing status became worse. No additional issues will be filed if your package remains in this state, and no issue will be filed if it improves. If you'd like to opt-out of these status-change messages, reply to this message saying you'd like to and @IainNZ will add an exception. If you'd like to discuss PackageEvaluator.jl please file an issue at the repository. For example, your package may be untestable on the test machine due to a dependency - an exception can be added.

Test log:

INFO: Cloning cache of Tau from git://github.com/Aerlinger/Tau.jl.git
INFO: Installing Tau v0.0.3
INFO: REQUIRE updated.
ERROR: test error during :((Base.return_types(f,(T,))==[T]))
return_types not defined
 in anonymous at test.jl:53
 in do_test at test.jl:37
 in anonymous at no file:25
 in include at boot.jl:238
at /home/idunning/pkgtest/.julia/v0.2/Tau/test/runtests.jl:27
INFO: REQUIRE updated.

`sinτ` etc. should be removed

because Base.sinπ is not defined.

Add sintau, costau, modtau

I don't know of any precedent for these, but since base has sinpi, cospi, and mod2pi, these might be useful.

Compatibility with Julia 0.4

Currently testing in 0.4 fails: https://github.com/waldyrious/Tau.jl/pull/1

To fix this, Compat macros will almost certainly be needed.

See #12 for context.

Document the functions

sintau etc have no documentation. It would be helpful to know what they are supposed to do.

(re)implement equality with 2pi

I have been collecting some loose notes about this but hadn't posted a plan publicly as I didn't have a clear plan of how to go about tackling this. But given @giordano's recent involvement with the package (and with the overall handling of Irrational in julia), I feel the time is right to move ahead and make a decision.

As the README indicates, this package was originally meant to provide the tau == 2pi equality (which should by definition be true). This is not possible at the moment due to the * operator implicit in 2pi converting the result of that expression to a float, which Irrationals are explicitly defined as not equal to. However, since this package was created explicitly to give special meaning to the value of 2pi, it would make sense for it to ensure that 2pi handles as the same Irrational as well. This may not be in scope for base Julia (@StefanKarpinski often expresses his concern that at some point these changes will drift towards implementing a full-fledged math parsing engine or CAS), but it sounds reasonably in scope for a package like this.

One way of doing so could be using Julia's core feature of multiple dispatch to override the * operator for the case where the operands are pi and 2, as I suggested a while ago in this thread. There is even some precedent for such special cases in base julia: exp.jl, for instance, has a special case for exp(1), implemented using a simple if test.

Instead of an if test, I have been looking at Value types to implement this. PatternDispatch could also provide inspiration for possible alternative approaches. These options may be overkill for the single 2pi case, but may be adequate if we want something more generic.

Indeed, a more general solution could be more appropriate: integer multiples of pi (or tau) should, for semantic reasons, be handled with the same manner as pi/tau itself. @simonbyrne suggested such a PiMultiple type in the PR that introduced sinpi/cospi, and I think the Tau package could make that experiment with a TauMultiple type.

Ok, now that I made the case, I'm curious about any arguments against. In particular, I'm wondering why @giordano considers that "it's exactly the fact that tau isn't the same as 2 * pi that makes this package particularly useful."

Missing `cistau`

What is says on the box.

julia> using Tau

julia> costau
cosτ (generic function with 2 methods)

julia> sintau
sinτ (generic function with 2 methods)

julia> cistau
ERROR: UndefVarError: cistau not defined

[PkgEval] Tau may have a testing issue on Julia 0.4 (2015-01-30)

PackageEvaluator.jl is a script that runs nightly. It attempts to load all Julia packages and run their tests (if available) on both the stable version of Julia (0.3) and the nightly build of the unstable version (0.4). The results of this script are used to generate a package listing enhanced with testing results.

On Julia 0.4

On 2015-01-29 the testing status was Tests pass.
On 2015-01-30 the testing status changed to Tests fail, but package loads.