Can someone point to me where I can find Finite Element Delphi library.
Preferably opensource.
Never tried, no releases, but source code is available: http://oofem.codeplex.com/
However, this CodePlex project appears to require the MtxVec math library from Dew Research which is not open source or free. (Note the 'uses MTxVec' in the source code).
Edit:
I accepted the answer: It's sofar the only advanced opensource Delphi I come accross.
To share my other findings, I suggest the following french resources (in academia):
Méthode des éléments finis: programmes écrits en Pascal (source code samples in Delphi).
RDM 6.17 (Binary distribution only).
I don't know of any that exist anymore since the heyday of Pascal being used for numerical methods work in the 80's. You best bet is to look into the C++ or FORTRAN projects listed at: http://en.wikipedia.org/wiki/List_of_numerical_libraries and either convert the code or link to the binaries. If you can use a commercial library, the NAG library has a write up on using Delphi with their DLLs at: http://www.nag.com/numeric/BorlandDelphi.asp.
You can also try here, scroll down to 'Free/Open Source/Shareware Packages' - lots listed, but language is not specifed.
Related
I am working with an undocumented, 100.000 lines Delphi 7 project and one of my goals is to create a software architecture document from the source code.
Can you give me any ideas on how to approach this?
These tools work with Delphi 7 and are of great help:
the UML tool ModelMaker
the refacotoring tool ModelMaker Code Explorer
the documentation tool Documentation Insight (as of august 2012)
UML diagrams are a great way to get an overview of structure. How well that overview is, depends on how well the structure is.
For taking over projects like these, I start with some basic documentation (often in MarkDown format, as that text based format is version control friendly, and generates nice HTML).
To get that going, it helps if the original developers or/and some base documentation are still there.
Then just start to:
fix bugs / apply feature requests
use ModelMaker to get a feel for overall structure
use ModelMaker Code Explorer as a refactoring tool
use Documentation Insight to document inside the source code (you can generate help files and web pages with the pro version, see feature matrix)
update my Markdown documents with any information that does not fit in the source code documentation well
Note you can put some documentation in using Model Maker Code Explorer, but it can not be exported as help files, since it uses a different documentation format than Documentation Insight.
So I agree with the comment by Jan Doggen (thanks Jan!): just start. Make sure you have the right tools to help that going.
Try running the source code through a newer Delphi version that supports UML modeling, then let it show you how different sections of code related to each other.
Understand will do the job. Free download includes 15 days evaluation which will be more then enough for what you need to document.
just looking for some implementation of arbitrary large integer numbers with some basic arithmetic (add, mul, div at least) for Delphi.
All solutions I did already found are either painfully slow(FGInt, BigInt, MyBigInt, UBigInts), i386 CPU specific (sdpbigInt) or implemented in C (MPIR/GMP).
So far the best results got with Delphi GMP wrappers for MPIR, but I'd prefer pure Delphi/Asm library (MPIR requires C compiler installed and knowledge of C if would like to study algorithms or do some tweaks).
I've read positive comments about NX multiprecision library written by Marcel Martin, but unfortunately it's no more available to download from the official site at http://www.ellipsa.eu . As code was distributed as freeware including sources, I do not find a problem to get it from other site. Can anybody throw in some alternate download link, please ?
Thanks in an advance.
Since you didn't specifically ask for a free alternative: StreamSec Tools 4.0. It contains hand optimized assembler for both x86 and x64 and comes with source.
I am seeking to understand someone else's code in Delphi 7 (I suspect that newer version have this built in, but I don't want to spring > $1k for the newest version).
Are their any (preferably FOSS) tools which will help me generate a class hierarchy diagram?
Actually, the class browser in GExperts is ok. Maybe not as good as the accepted answer, but just one of a great collection of tools
You can use ESS-model from SourceForge.
If you Load and .PAS (also .DPR, .CLASS,...) with some classes this program generate a Class Diagram and some Documentation. It's free and you can access to code source.
Regards
AFAIK ModelMaker 6.2 was included with Delphi 7, it's a UML tool. You can import your source code in it and generate class diagrams etc, I really don't remember anymore all of it's features, but I do remember that ModelMaker is awesome tool and it's sure worth a look.
Update: Model Maker (now MMX) is now free for all supported Delphi IDEs
You can take a look at our SynProject tool.
Synopse SynProject is an open source application for code source versioning and automated documentation of Delphi projects.
There is a pascal source parser, which will create all classes hierarchy documentation.
And it's much more than a parser: you can write the whole Specifications/Architecture/Design/Test/Release documents list in an integrated manner.
There are some tutorials, screenshots and resulting documentation sample in the above link.
Peganza's Pascal Analyzer (not FOSS)
Doc-o-matic's documentation generator creates class hierarchies. They have a free express version you can try.
We're trying to untangle a hairball of 100's of units, removing some.
It would be helpful if there was tool that would show us what units were explicitly using unit X.
Penganza doesn't seem to have a report that does that. (Although it has lots of other useful reports.)
Can anyone suggest a tool or strategy for doing this, other than just hiding unit x and then hitting F9 ... repeatedly?
MMX (Model Maker Code Explorer) has a nice unit dependency analyzer (it is especially good at detecting cycles).
For more details, see this answer.
--jeroen
From a similar question here
You might want to take a look at at
CnPack.
CnPack includes a Uses cleaner
wizard wich hasn't failed me yet.
GExperts can show Project Dependencies.
Peganza Pascal Analyzer can do the work. I haven't worked with it much, but a former dev here wrote a system that uses PAL to do the analysis, then dumped the results into a database, and then there's a browser app that lets you enter a unit name and it returns the list of units affected, whether they would need to be rebuilt if the unit changed, or if the interface changed. We use lots of BPLs so you can sometimes change a unit and you don't have to re-build other binaries that use your unit, unless the interface changed. This saves us lots of work (hundreds of BPLs and EXEs).
Chris
Headway Software's Structure 101g (and Restructure 101g) can do that really well, with the Delphi plugin.
Disclaimer: I wrote the flavors to analyze Delphi. I use them professionally, helping clients.
We've just released a freeware utility that does exactly what you need plus quite a bit more. It's called the Delphi Unit Dependency Scanner (DUDs) and you can download it here: http://www.easy-ip.net/delphi-unit-dependency-scanner.html
Sorry it's a bit late!
I was going to mention Icarus, but when I googled them I got this stack overflow answer, which you might want to check out.
Then again, sometimes I just like to delete my whole Unit Output Directory, then count my new DCU's, and that works too.
The reason you may like Icarus and not GExperts is that it doesn't rely on you to have properly maintained the uses statements in your project file.
A newcomer in this field is the Delphi Plugin for Sonar. It does not list unit dependencies but can find unused files and "dead" code (and more).
Implemented features:
Counting lines of code, statements, number of files
Counting number of classes, number of packages, methods, accessors
Counting number of public API (methods, classes and fields)
Counting comments ratio, comment lines (including blank lines)
CPD (code duplication, how many lines, block and in how many files)
Code Complexity (per method, class, file; complexity distribution
over methods, classes and files)
LCOM4 and RFC
Code colorization
Unit tests reports
Assembler syntax in grammar
Include statement
Parsing preprocessor statements
Rules
Code coverage reports
Source code highlight for unit tests
“Dead” code recognition
Unused files recognition
If you have been successful in persisting your data, which type of stream did you get to work
Text or Binary
ANSI or UNICODE
Did you have to use any BOOST_ASSERTS or some extra MACRO or dance around the fairy ring at 4:00 am wearing your Moose sweater backwards.
Thanks for your answer
There is a posting for C++Builder 2010 (unfortunately I do not know of one for 2009), that shows the portions of the Boost (1.39) that are included in the shipping product. The serialization library is listed as not supported. Note the posting also includes a link to the source code they used in case someone wants to experiment with the unsupported libraries.
I haven't tried, so I can't directly answer. However, here are the boost 1.37.0 test results for C++Builder 2009 (the column on the right, "borland-6.1.0").
You can see most things in 'serialization' pass the tests. Some don't, so if you compare what you're trying to do to those it should help you to know what to avoid. The test suites may also useful to you, because they can be used as code examples for using the features they test.
You may find other resources on the C++ Builder Boost page to be useful too.