Thursday, June 22, 2006
Not related to the weblog but Full of Fortran Websites



http://dmoz.org/Computers/Programming/Languages/Fortran/Tools/
Written at 9:41 PM By Siamak Faridani
0 comments
F90VB

http://www.canaimasoft.com/f90VB/Overview.htm


f90VB is a set of four Fortran libraries that provide the functionality necessary for your Fortran programs to gain access to COM/ActiveX objects. In addition, you can use f90VB to call Visual Basic DLLs from your Fortran applications, or to create Fortran DLLs that are able to handle intrinsic Visual Basic data types (like VB's strings, arrays or variants). f90VB also includes TLView, a professional quality Type Library browser, that can be used as a tool to explore COM/ActiveX objects you are using from your Fortran applications.

Written at 9:36 PM By Siamak Faridani
0 comments
Fortran GUI from Mathtools
Wrapid - generate a GUI for your Fortran programs Update Link / Bad Link?
Wrapid is a tool which allows a modern windows user interface to be quickly added to a Fortran program. Usually no changes are required to the existing Fortran code.
Submitted Nov 25, 2004 by Ian Hawkins
Updated Nov 29, 2004
Rating: (1 Ratings) Rate this link Total Visits: 298
The FORTRAN interface Update Link / Bad Link?
This section describes the subroutines that can be called from a FORTRAN program to interface with the Graphics Window Manager. All these routines use the inherited status strategy which means that if the STATUS argument is not set to the value SAI__OK on entry the routine will exit without performing any action. If an error occurs during the execution of a routine the STATUS will be set and an error will be reported using the error message service (EMS---SUN/104).
Submitted Mar 24, 2000
Rating: (1 Ratings) Rate this link Total Visits: 185
GINO graphics - GINOMENU Studio v2.0 Update Link / Bad Link?
GINOMENU Studio is an interactive GUI builder and development environment specifically aimed at the Fortran programmer. Developers can create a graphical user-interface by drag-and-drop methodology without having to write any source code at all. GINOMENU Studio is a self-contained GUI builder that doesn't rely on resources or dialogs having to be created with another application. When the layout is complete, the GUI can be saved as Fortran-77 or Fortran-90 code containing calls to GINOMENU. This code can then be compiled, linked and run from within the Studio to check the final appearance of the application. All common widget types are available in GINOMENU Studio including buttons, check boxes, radio boxes, sliders, status bars, toolbars, text/value entry boxes, text/value arrays, graphics frames, panels and list boxes/combo boxes. The properties of each widget can be changed such as label, name, title-bar, size and colour and GINOMENU Studio includes a full callback editor eroviding a quick and easy way of developing GUI's and at last provides a true 'Visual' Fortran.
Rating: N/A Rate this link Total Visits: 125
f90gl: Fortran interface for OpenGL and GLUT Update Link / Bad Link?
f90gl is a public domain implementation of the official Fortran 90 bindings for OpenGL. The current version is Version 1.2.1 This version implements the interface for OpenGL 1.2, GLU 1.2, GLUT 3.7, and several extensions. It supports several Unix workstations and Windows 95/98/NT. It is also the Fortran interface for Mesa.
Submitted Feb 29, 2000
Rating: N/A Rate this link Total Visits: 70
Fortran Interface Update Link / Bad Link?
The Fortran (F77) interface is provided, but certain features have necessarily been omitted (awaiting Fortran 90). The syntax is different since there are no pointers in F77. There are no user-defined types provided in the Fortran interface as Fortran does not provide structures. Once Fortran 90 has been adopted, user-defined types will likely appear in the Fortran interface.
Submitted Mar 24, 2000
Rating: N/A Rate this link Total Visits: 60
FORTRAN callable interface Update Link / Bad Link?
The FORTRAN callable interface consists of the CZ and XZ packages. Normally, only the XZ package is of concern to the user: any calls to the CZ package being made in a completely transparent manner. The exception to this case is of course when a new application that requires a different server is to be built.
Submitted Mar 24, 2000
Rating: N/A Rate this link Total Visits: 35
Fortran 77 Interface Update Link / Bad Link?
This chapter describes the Fortran 77 interface with C++.
Submitted Mar 29, 2000
Rating: N/A Rate this link Total Visits: 34
Interactive Software Services Ltd. Update Link / Bad Link?
This is a UK based software company specializing in the development of user-interface and graphics tools for use with the Fortran programming language. Our products are designed to allow non-specialist programmers, such as scientists and engineers, to add modern user interface and graphics features to their Fortran based software.
Submitted Mar 29, 2000
Updated Dec 21, 2004 by Sebastian Di Laura
Rating: N/A Rate this link Total Visits: 31
C-Fortran Interface Update Link / Bad Link?
You may want to assemble programs from a mixture of C and Fortran modules. One reason might be to call Fortran graphics routines from the MONGO or PGPLOT libraries from a C program. Another might be to call a C function that manipulates character strings in some way that is ugly, or impossible, in Fortran. Many Unix compilers have a somewhat standard procedure for mixing C and Fortran modules. The procedures decribed here are specific to the Sun operating system, but may carry over to other flavors of Unix.
Submitted Mar 24, 2000
Rating: N/A Rate this link Total Visits: 20
Fortran Interface Primer Update Link / Bad Link?
The Fortran interface allows NAO objects to be created, used and deleted from a Fortran program. The Fortran interface is functionally equivalent to the Raw interface, being Stub routines which turn around and call the Raw interface. There are two important issues that arose when we created this interface: how to generate names for the Fortran routines that call the Raw interface, and how to pass objects between C++ and Fortran. These are discussed in some detail below.
Submitted Mar 24, 2000
Rating: N/A Rate this link Total Visits: 20
Interfacing with C with Absoft Fortran compilers Update Link / Bad Link?
Absoft Fortran 77 and 90 are designed to be fully compatible with the Absoft C/C++ and the Microsoft C/C++ compilers. The linker can be used to freely link C modules with Fortran main programs and vice versa. However, some precautions must be taken to ensure proper interfacing. Data types in arguments and results must be equivalent and some changes to the linking procedure must be made. All of these rules are detailed below. Be sure to follow them closely, or the results will be both unpredictable and invalid.
Submitted Mar 29, 2000
Updated Jan 09, 2006 by Nicholas Nagle
Rating: N/A Rate this link Total Visits: 18
ADOL-F Update Link / Bad Link?
ADOL-F is a FORTRAN 90 interface to the ADOL-C library and uses operator overloading for the evaluation of arbitrary order derivatives of vector functions that are defined by computer programs written in FORTRAN 90/77. The package provides various drivers for the derivative evaluation by forward and reverse mode, drivers for common optimization tasks and ODEs.
Submitted Feb 29, 2000
Rating: N/A Rate this link Total Visits: 12
The SYSREQ FORTRAN interface Update Link / Bad Link?
This routine sends the specified command to the named service via the SYSREQ mechanism. One may also use the routine FMSREQ, which is part of the FATMEN [] and resides in PACKLIB. This routine as the same calling sequence as SYSREQ, but provides automatic protection against network problems (timeouts etc.) with retry were required.
Submitted Mar 24, 2000
Rating: N/A Rate this link Total Visits: 9
Written at 9:28 PM By Siamak Faridani
0 comments
Taken From WIKIPEDIA- Free GUI Libraries

Free graphical libraries/GUI

[edit]

Proprietary/non-free graphical libraries/GUI

  • DISLIN: "DISLIN is a high-level plotting library for displaying data as curves, polar plots, bar graphs, pie charts, 3D-color plots, surfaces, contours and maps." For DOS, Linux, Mac OS X, OpenVMS, UNIX, Windows. "Free for non-commercial use" (but not free).
  • SansGUI: Requires Microsoft Visual C/C++ 6.0+ or Compaq Visual Fortran 6.1+. For Windows.
  • Winteracter: "The Fortran 9x GUI Toolset." For Linux, Mac OS X, Windows.
Written at 9:18 PM By Siamak Faridani
0 comments
Xeffort for win

http://www.xeffort.com/xeffort/home.htm

Xeffort library (previously known as XFT) is used for easy building Win32 GUI applications with Compaq and Intel Visual Fortran compilers. It seamlessly integrates with Microsoft Visual Studio (.NET) IDE providing:

•

Application wizard, for quick creating of skeleton MDI, SDI or dialog-based applications

•

Handler wizard, for creation of prototypes of most-frequently used routines

•

Online help, which can be run from Visual Studio "Tools" menu

Xeffort is distributed as free, open source resource.

Xeffort is both a framework (meaning that you can build GUI applications using solely Xeffort APIs) and a library (meaning that you can call selected Xeffort routines from any Win32 application without using full set.)

Currently, Xeffort is available only for Compaq/(Intel) Visual Fortran compiler since it partially depends on some extensions, namely, integer (Cray) pointers and DEC$ metacommands. Your possible effort to port it to other compilers is welcome.

Versions and Compatibility

Xeffort can be used in two flavors: "Lite" and "Full". "Lite" version consists of a limited set of modules which present useful functions in any kind of application without additional overhead. Currently, the following modules are provided in "Lite" flavor: XFTGDI, XFTFile, XFTMenu, XFTReg and XFTStrings. These modules can be included into your projects and compiled separately of the rest of Xeffort library.

"Full" version of the package presents a complete framework built on top of Win32 API, and it provides functions able to build an entire GUI application of moderate complexity. However, the open architecture of Xeffort enables that both - "Lite" and "Full" flavors can be used on top of existing code, regardless whether it's a console, QuickWin, dll or Win32 application - in just few steps you're able to bind Xeffort windows with your existing application windows and add new functionality.

Xeffort Full version carries along an independent set of interfaces for Win32 functions and structures so that it is not dependent on DFWIN upgrades throughout CVF development, thus it should work on any CVF version.

Xeffort Full version is most easily used as a static library (Xeffort.lib) along with a set of modules (*.mod). Xeffort Lite modules can be used as separate .f90 files inserted into your projects.

Written at 9:16 PM By Siamak Faridani
0 comments
Combining Fortran and Tcl in one program

Combining Fortran and Tcl in one program

Arjen Markus (7 november 2002) I have written an article on the use of Tcl in a Fortran program. (Fortran Forum, december 2002). Below you will find a fragment of that article, describing a small client-server system for on-line visualisation:

  • The Fortran program does a calculation and uses Tcl to send the results to a server program
  • The server program displays the results in a graphical form

It is meant to demonstrate how easy it is to combine Fortran and Tcl and do novel things with them.

Note: If you are interested in the library, just e-mail me.

To apply Tcl within a program you need to interact with the run-time system, the Tcl interpreter. This is actually a collection of variables and Tcl routines. Most commonly there is only one interpreter, but there are classes of applications where several are used at once, as each may act quite independently, for instance in client/server systems.

I created a small library to facilitate the interaction:

  • One routine, ftcl_start, to initialise the one interpreter that will remain active during the whole program run. It can optionally run a startup script from file.
  • A set of routines to set the values of variables in the interpreter (one for each common data type, but via the interface mechanism in Fortran, they present themselves as a single routine, ftcl_set)
  • A set of routines to get the values of variables in the interpreter (likewise, externally they are visible as a single routine, ftcl_get).
  • One routine to evaluate Tcl scripts (one or more commands; ftcl_script)

With this library I created a small demonstration program, an almost trivial simulation, that provides on-line visualisation of the results:

 ! Simple program to show the Ftcl library
!
program calc
   use FTCL
   implicit none

   integer       :: i
   integer       :: nosteps
   real          :: x
   real          :: y
   real          :: dphi
   real          :: phi

!
! Start the Tcl interpreter, and read the major parameters
!
   call ftcl_start( 'calc.tcl' )
   call ftcl_get( 'dphi', dphi )
   call ftcl_get( 'nosteps', nosteps )

!
! Run the calculation and output the variables
!
   do i = 0,nosteps
      phi = real(i) * dphi
      x = cos( phi )
      y = sin( phi )
      call ftcl_put( 'x', x )
      call ftcl_put( 'y', y )
      call ftcl_script( 'transfer' )
   enddo

   call ftcl_script( 'close_transfer' )
   stop
   end

The interesting feature here is that the Fortran program does not need to know anything about the output mechanism - this is all put into the Tcl routine transfer.

The script file that is run when initialising the interpreter looks like this:

 # Define the routines to send data to the server
#
proc transfer { } {
    global channel
    global x
    global y
   puts $channel "$x $y"
   flush $channel
}
proc close_transfer { } {
   global channel
   close $channel
}

#
# SetUp accepts zero or one arguments, if there is no argument,
# use the local host.
#
proc SetUp  { {host localhost} } {
   global channel
   set port    8085

   set channel [ socket $host $port ]
}

SetUp

#
# Set the computational parameters
#

set nosteps 100
set dphi    0.1

The routine SetUp sets up a socket connection to the local host (as there is no host name given). The routine transfer writes the values of the variables x and y to the channel and flushes it to make sure the output is available immediately on the receiving side.

The receiving side is a somewhat less simple Tcl script that uses the graphical toolkit, Tk, to display the input (the x and y coordinates) graphically:

 #
# SetUp the server side (it needs to "listen" to the port)
#
proc SetUp  { } {
   set port    8085
   set timeout 60000

   socket -server [list Accept $timeout] $port

   # We run in a graphical (Tk) shell, so an event loop is
   # already available: the next statement is not required.
   # vwait forever
}

#
# Procedure that accepts the client and sets up the connection
#
proc Accept { timelimit socket ip args } {
   fconfigure $socket -block false
   fileevent  $socket readable [list DrawInput $socket]
}

#
# Draw the input graphically
#
proc DrawInput { socket } {
   global xprev yprev

   if { ! [eof $socket] } {
      gets $socket line
      set x [lindex $line 0]
      set y [lindex $line 1]

      if { $x != "" && $y != "" } {
         set xc [expr 100+80*$x]
         set yc [expr 100+80*$y]
         .c create line $xprev $yprev $xc $yc -fill black
         set xprev $xc
         set yprev $yc
      }
   }
}

#
# Main code: create a window in which we can draw and start
# the server .
#
global xprev yprev

set xprev 0.0
set yprev 0.0

canvas .c -background white
pack .c

SetUp

The server's version of SetUp creates a so-called server socket and then enters an event loop (explicitly via the command vwait or automatically because the runtime environment is graphical). The other routines have to do with the handling of incoming requests and incoming data. The result is a very simple picture.

AM Thanks to Clif Flynt this little library is now capable of using Tk within a Fortran program. This means you can build a Fortran program with a very portable GUI ... Just thought to mention this, as the interest in this library has increased a lot over the past couple of months.

AM (2 july 2004) One place to find the library is: http://www.digitalsmarties.com/tcl/ftcl.zip

Category Foreign Interfaces

Written at 9:10 PM By Siamak Faridani
0 comments
Best Tools as GUI
GINO
Wintractor
Written at 9:02 PM By Siamak Faridani
0 comments
DISLIN
http://www.mps.mpg.de/dislin/

DISLIN Home Page
Welcome to the home page of the scientific data plotting software DISLIN.

DISLIN is a high-level plotting library for displaying data as curves, polar plots, bar graphs, pie charts, 3D-color plots, surfaces, contours and maps.

DISLIN is intended to be a powerful and easy to use software package for scientists and programmers. There are only a few graphics routines with a short parameter list needed to display the desired graphical output. A large variety of parameter setting routines can then be called to create individually customized graphics.

The software is available for several C, Fortran 77 and Fortran 90/95 compilers on the operating systems UNIX, Linux, FreeBSD, OpenVMS, Windows and MS-DOS. DISLIN programs are very system-independent, they can be ported from one operating system to another without any changes.

For some operating systems, the programming languages textExtern Python, textExtern Perl and textExtern Java are also supported by DISLIN. The DISLIN interpreter DISGCL is availble for all supported operating systems. See a complete list of the supported operating systems and compilers.

A short description of the DISLIN features is given in Overview. DISLIN manuals can be downloaded as compressed tar files in PostScript, PDF and HTML format. An online manual is also available as an alphabetical list of all DISLIN routines. A PowerPoint presentation of DISLIN is available in the file dislin.ppt.

DISLIN is free for non-commercial use. Licenses for selling programs linked with DISLIN or for using DISLIN in an environment related to business are available from this site.

The DISLIN software and manuals can be downloaded via HTML and from FTP server
Written at 8:39 PM By Siamak Faridani
0 comments
Images




Written at 8:16 PM By Siamak Faridani
0 comments