V0.0.1

• Define scope;
• Determine challenges;
• Identify critical issues;
• Initial architecture design;

svn co https://jquant.svn.sourceforge.net/svnroot/jquant/tags/TAG-0.0.1-RELEASE/jquantlib/

• Scope: The first release must be enough for compiling without errors the demonstration program EquityOptions till the line 236, where Black&Scholes model is used to calculate European options.
• Challenges: Create a good proof of concept which expresses well the compromises with a fast and developer friendly code. The implementation must be clean, simple and readable. It must use as fast as possible via the use of primitive types whenever possible in order to obtain good execution time.
• Critical issues

1. Strong type checking with semantic information;
2. Fast mathematical calculations;
3. Multiple inheritance in Java;
4. Observable interface (and not Observable class)
5. Templates in Java;
6. Professional documentation with formulas;

• Design decisions

1. Java lacks some useful constructions C++ has, such like typedef. This language feature which helps on strong type checking is considered critical for correctness of JQuantLib due to the complexity of the original C++ code and the possibility of mistakes very difficult to identify. The alternatives and the proposed solution is discussed at DesignTypeChecking.
2. Producing fast code whilst providing strong type checking is even more challenging, as a double does not have any strong type signature from the semantic point of view of a certain business object. Hopefully, the solution for this problem is partly addressed by DesignTypeChecking. More considerations on performance can be seem at DesignPerformance.
3. As the original C++ code uses multiple inheritance whenever necessary, JQuantLib must offer a simple, clean and well documented way to provide this language feature. As you probably know well, multiple inheritance is not provided in Java. The proposed solution for this problem can be seem at DesignMultipleInheritance;
4. Observable pattern as it is implemented in the JDK is not friendly for multiple inheritance. Due to this reason, we implemented our own Observable and Observer classes. The solution is presented at DesignObservablePattern
5. Templates is a C++ language feature which basically can be understood as a very powerful and flexible macro processor which most of the times is used in a very crypt and over-complicated way by class designers. Our approach for C++ templates in Java is initially try to get rid of them whenever possible. If not possible or not desirable, substitute it's use by generic classes. The discussion is available at DesignCppTemplates
6. Javadocs provided by JDK are good but they are far from being a professional artifact for complex projects. In order to provide such artifact for JQuantLib, we added UML class diagrams and mathematical formulas to our documentation. See more details at DesignJavadocs