I have a project that I started a long time ago and licensed under GPLv3.

It uses an implementation of a particular algorithm, where the implementation is licensed under GPLv2.

The algorithm is the Fast Fourier Transform (FFT), in particular the Radix-2 Decimation-In-Time. The implementation is from MEAPsoft.

GPLv2 is not compatible with GPLv3, so I wish to get rid of the GPLv2 somehow so I can release the whole project under GPLv3 as I originally intended to.

Does the GPLv2 actually apply for this usage? And, if so, is there some way I can get rid of it?

There's another copyright header later down in the code, I didn't think to include it before since it points nowhere and doesn't specify a license but perhaps the original original FFT implementation/specification can be dug up.

Douglas L. Jones 
University of Illinois at Urbana-Champaign 
January 19, 1992 

(the link doesn't work)

This would suggest that this Java version is adapted from an earlier C implementation, which might have used a different license.

I'm no expert, but I see two conflicting ways to view this:

  • Algorithms are not owned by anyone, therefore I should not be restricted even if the implementation I am using is based on a GPLv2 licensed one.
  • The GPLv2 infects any derivative works, and since I have nothing else to base an implementation on, any implementation of the algorithm I make is automatically a derivative work of the original, and under GPLv2.

If more details might be needed, here's the relevant bits of the timeline:

  • My project goes on GitHub, released under GPLv3.
  • The entire Radix-2 DIT FFT implementation is brought into the project.
  • I add some API on top of the FFT.
  • I add some tests and benchmarks for the FFT.
  • Rewrites happen across several git commits. Unneeded sections are removed. Input checks are added. The algorithm is further optimized. All parts are documented. License header is kept.

I originally asked this somewhere else, before knowing about this stackexchange. So I ask here now.

  • 1
    "GPLv2 is not compatible with GPLv3, so I wish to get rid of the GPLv2 somehow" - Does the license include the upgrade option, e.g. "or (at your option) any later version" language? – Brandin Aug 17 '18 at 7:01
  • I see a .c version here: bohr.wlu.ca/hfan/cp467/examples/fft.c The MEAPSoft version that you linked to copies a version of this, but apparently the version they copied has a different license from Douglas Jones ("Permission to copy and use this program is granted as long as this header is included."). The first .c version is licensed under Creative Commons Attribution, which implies more obligations and not compatible with GPLv3. One possible solution is to copy only the fft.c function from Douglas Jones that uses the more permissive license. Then it would be compatible with GPLv3. – Brandin Aug 20 '18 at 7:56
  • So there does exist some version of the original under a permissive license, but we don't have a working link to it. Would it be a problem that I'm unable to link back to the source? Or is it enough that the header is there, even though the link doesn't work? – EPICI Aug 20 '18 at 21:57
  • The license header says only that the header be included. Generally open source licenses do not require "hyperlinks." If they did, it means that you would have to stop using the software as soon as that site stopped being maintained and supported. – Brandin Aug 21 '18 at 5:30
  • Seems like the page was last available in 2005: web.archive.org/web/20051204125313/http://cnx.rice.edu:80/… From that page apparently the page itself is licensed under Creative Commons but I interpret the code itself to be under a more permissive license ("as long as this header is included"). – Brandin Aug 21 '18 at 9:22

Copyright applies to creative expression. You are correct that algorithms are not expression as copyright understands the concept. However, when you look at the FFT code here, you've not looking at a pure algorithm-idea; you're looking at an expression of an algorithm. You might wonder: how, then, can we ever communicate any algorithm at all without a corresponding expression, which will involve copyright?

An important concept in copyright law is the merger doctine, which says that if an idea can be expressed only in a limited number of ways, or an expression contains nothing more than the barest possible expression of an idea, then the idea and expression are merged and the expression is ineligible for copyright.

I haven't investigated this case closely, but I would very hesitant to assume that this Java code is truly merged with the idea of the FFT algorithm. Different specific choices made by the author of the code may impact readability and performance. In other words, there could be a different implementation of this same algorithm that looks and reads differently (and even operates differently, from a performance standpoint). To the degree that such variance can exist, the work has creative expression covered by copyright.

You are free to examine an academic expression of the algorithm, build your own interal understanding of the algorithm-idea, and write your own expression of that idea, which will be distinct from the MEAPsoft implementation.

Note that the fact that you have looked at the MEAPsoft implementation may "taint" your ability to free yourself from the possibility that a court may view your independent re-implementation as a derivative. This kind of "subconscious copying" is an insidious problem in copyright law that is commonly problematic for musicians who accidentally copy one another. A traditional clean-room implementation ensures that people writing new code have never seen the original code.

One final option is to contact the authors of MEAPsoft and ask them to license their work under "GPLv2 or any later version" instead of GPLv2 only, which would allow you to distribute it within your GPLv3 work.

  • Seems to be no way to contact Columbia University or find who the original individual authors are to contact them. And sadly I have to agree that while there is only one "Radix-2 DIT" algorithm, an implementation can use different variable names or spacing or have other non-functional differences which are "creative". Which leaves my options seemingly at a clean room implementation. There's specifications on Wikipedia, so if I give those to a friend to implement, and I don't help from there, I'll be good to go? – EPICI Aug 17 '18 at 18:23
  • There's a lot of steps in the algorithm, and all of them need to be done, but there's some flexibility in the order. BFS-like or DFS-like, even first or odd first, etc. Then there's a choice of lookup tables and other optimizations. These things might be considered functional differences (even though the result is the same) and be enough variation to make the implementation not merged with the algorithm. – EPICI Aug 17 '18 at 18:44
  • @EPICI The example you cite is clearly copied. It would be possible to reimplement this in a clean room way and avoid copyright issues, but that does not look like it was attempted here at all. The comment header even says it was copied from "Douglas L. Jones, University of Illinois at Urbana-Champaign..."; every line is nearly identical or derivative (e.g. replacing a call to cos(x) with a call to lookup table of cos), all variable names are the same, etc. The only significant change I noticed was replacing a += e in the C version with a += 1 << (m-i-1) in the Java version. – Brandin Aug 20 '18 at 7:59

Your Answer

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.

Not the answer you're looking for? Browse other questions tagged or ask your own question.