Articles de revues : « Object-oriented fortran »

1

Hirchert, Kurt. « Object oriented programming and Fortran ». ACM SIGPLAN Fortran Forum 15, n^o 2 (août 1996) : 23–26. http://dx.doi.org/10.1145/242719.242728.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

2

Meissner, Loren P., John S. Cuthbertson et William B. Clodius. « Fortran object oriented programming examples ». ACM SIGPLAN Fortran Forum 15, n^o 1 (avril 1996) : 11–12. http://dx.doi.org/10.1145/228826.228832.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

3

Gorelik, A. M. « Object-Oriented Programming in Modern Fortran ». Programming and Computer Software 30, n^o 3 (mai 2004) : 173–79. http://dx.doi.org/10.1023/b:pacs.0000029582.33766.ba.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

4

Akin, J. E. « Object oriented programming via Fortran 90 ». Engineering Computations 16, n^o 1 (février 1999) : 26–48. http://dx.doi.org/10.1108/02644409910251210.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

5

Schonfelder, Lawrie. « Fortran 90 is almost object-oriented ». ACM SIGPLAN Fortran Forum 12, n^o 2 (juin 1993) : 21–22. http://dx.doi.org/10.1145/155886.155889.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

6

Dupée, Brian J. « Object oriented methods using Fortran 90 ». ACM SIGPLAN Fortran Forum 13, n^o 1 (mars 1994) : 21–30. http://dx.doi.org/10.1145/191559.191563.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

7

Decyk, Viktor K., Charles D. Norton et Boleslaw K. Szymanski. « Expressing object-oriented concepts in Fortran 90 ». ACM SIGPLAN Fortran Forum 16, n^o 1 (avril 1997) : 13–18. http://dx.doi.org/10.1145/263877.263880.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

8

Patton, Bob. « Object-oriented Fortran 77 (a practitioner's view) ». ACM SIGPLAN Fortran Forum 12, n^o 2 (juin 1993) : 23–24. http://dx.doi.org/10.1145/155886.155891.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

9

Nanthaamornphong, Aziz, Jeffrey Carver, Karla Morris et Salvatore Filippone. « Extracting UML Class Diagrams from Object-Oriented Fortran : ForUML ». Scientific Programming 2015 (2015) : 1–15. http://dx.doi.org/10.1155/2015/421816.

Texte intégral

Résumé :

Many scientists who implement computational science and engineering software have adopted the object-oriented (OO) Fortran paradigm. One of the challenges faced by OO Fortran developers is the inability to obtain high level software design descriptions of existing applications. Knowledge of the overall software design is not only valuable in the absence of documentation, it can also serve to assist developers with accomplishing different tasks during the software development process, especially maintenance and refactoring. The software engineering community commonly uses reverse engineering techniques to deal with this challenge. A number of reverse engineering-based tools have been proposed, but few of them can be applied to OO Fortran applications. In this paper, we propose a software tool to extract unified modeling language (UML) class diagrams from Fortran code. The UML class diagram facilitates the developers' ability to examine the entities and their relationships in the software system. The extracted diagrams enhance software maintenance and evolution. The experiments carried out to evaluate the proposed tool show its accuracy and a few of the limitations.

Styles APA, Harvard, Vancouver, ISO, etc.

10

Crutchfield, William Y., et Michael L. Welcome. « Object-Oriented Implementation of Adaptive Mesh Refinement Algorithms ». Scientific Programming 2, n^o 4 (1993) : 145–56. http://dx.doi.org/10.1155/1993/838429.

Texte intégral

Résumé :

We describe C++ classes that simplify development of adaptive mesh refinement (AMR) algorithms. The classes divide into two groups, generic classes that are broadly useful in adaptive algorithms, and application-specific classes that are the basis for our AMR algorithm. We employ two languages, with C++ responsible for the high-level data structures, and Fortran responsible for low-level numerics. The C++ implementation is as fast as the original Fortran implementation. Use of inheritance has allowed us to extend the original AMR algorithm to other problems with greatly reduced development time.

Styles APA, Harvard, Vancouver, ISO, etc.

11

Norton, Charles D., Viktor K. Decyk, Boleslaw K. Szymanski et Henry Gardner. « The Transition and Adoption to Modern Programming Concepts for Scientific Computing in Fortran ». Scientific Programming 15, n^o 1 (2007) : 27–44. http://dx.doi.org/10.1155/2007/146752.

Texte intégral

Résumé :

This paper describes our experiences in the early exploration of modern concepts introduced in Fortran90 for large-scale scientific programming. We review our early work in expressing object-oriented concepts based on the new Fortran90 constructs – foreign to most programmers at the time – our experimental work in applying them to various applications, the impact on the WG5/J3 standards committees to consider formalizing object-oriented constructs for later versions of Fortran, and work in exploring how other modern programming techniques such as Design Patterns can and have impacted our software development. Applications will be drawn from plasma particle simulation and finite element adaptive mesh refinement for solid earth crustal deformation modeling.

Styles APA, Harvard, Vancouver, ISO, etc.

12

Norton, Charles D., Viktor K. Decyk et Boleslaw K. Szymanski. « On parallel object oriented programming in Fortran 90 ». ACM SIGAPP Applied Computing Review 4, n^o 1 (avril 1996) : 27–31. http://dx.doi.org/10.1145/240732.240742.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

13

Wilkes, Maurice V. « From Fortran and Algol to object-oriented languages ». Communications of the ACM 36, n^o 7 (juillet 1993) : 21–23. http://dx.doi.org/10.1145/159544.159553.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

14

Achee, B. L., et Doris L. Carver. « Creating object-oriented designs from legacy FORTRAN code ». Journal of Systems and Software 39, n^o 2 (novembre 1997) : 179–94. http://dx.doi.org/10.1016/s0164-1212(96)00171-9.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

15

Budimlić, Zoran, Ken Kennedy et Jeff Piper. « The Cost of being Object-Oriented : A Preliminary Study ». Scientific Programming 7, n^o 2 (1999) : 87–95. http://dx.doi.org/10.1155/1999/464598.

Texte intégral

Résumé :

Since the introduction of the Java programming language, there has been widespread interest in the use Java for the high performance scientific computing. One major impediment to such use is the performance penalty paid relative to Fortran. To support our research on overcoming this penalty through compiler technology, we have developed a benchmark suite, called OwlPack, which is based on the popular LINPACK library. Although there are existing implementations of LINPACK in Java, most of these are produced by direct translation from Fortran. As such they do not reflect the style of programming that a good object‐oriented programmer would use in Java. Our goal is to investigate how to make object‐oriented scientific programming practical. Therefore we developed two object‐oriented versions of LINPACK in Java, a true polymorphic version and a “Lite” version designed for higher performance. We used these libraries to perform a detailed performance analysis using several leading Java compilers and virtual machines, comparing the performance of the object‐oriented versions of the benchmark with a version produced by direct translation from Fortran. Although Java implementations have been made great strides, they still fall short on programs that use the full power of Java’s object‐oriented features. Our ultimate goal is to drive research on compiler technology that will reward, rather than penalize good object‐oriented programming practice.

Styles APA, Harvard, Vancouver, ISO, etc.

16

Nanthaamornphong, Aziz, et Anawat Leatongkam. « Extended ForUML for Automatic Generation of UML Sequence Diagrams from Object-Oriented Fortran ». Scientific Programming 2019 (5 février 2019) : 1–22. http://dx.doi.org/10.1155/2019/2542686.

Texte intégral

Résumé :

Recently, reverse engineering has become widely recognized as a valuable process for extracting system abstractions and design information from existing software. This study focuses on ForUML, a reverse engineering tool developed to extract UML diagrams from modern object-oriented Fortran programs. Generally, Fortran is used to implement scientific and engineering software in various domains, such as weather forecasting, astrophysics, and engineering design. However, methods for visualizing the existing design of object-oriented Fortran software are lacking. UML diagrams of Fortran software would be beneficial to scientists and engineers in explaining the structure and behavior of their programs at a higher level of abstraction than the source code itself. UML diagrams can enhance discussions within development teams and with the broader scientific community. The first version of ForUML produces only UML class diagrams. Class diagrams provide a useful window into the static structure of a program, including the structure and components of each class and the relationships between classes. However, class diagrams lack the temporal information required to understand class behavior and interactions between classes. UML sequence diagrams provide this important algorithmic information. Therefore, herein, an extension for ForUML to extract UML sequence diagrams from the Fortran code is proposed, and this capability is provided using a widely used open-source platform. This study argues that the proposed extension will enable the visualization of object-oriented Fortran software behavior and algorithmic structure and thereby enhance the development, maintenance practices, decision processes, and communications in scientific and engineering software communities worldwide.

Styles APA, Harvard, Vancouver, ISO, etc.

17

Wampler, K. Dean. « The object-oriented programming paradigm (OOPP) and FORTRAN programs ». Computers in Physics 4, n^o 4 (1990) : 385. http://dx.doi.org/10.1063/1.168371.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

18

Akin, J. E., et M. Singh. « Object-oriented Fortran 90 P-adaptive finite element method ». Advances in Engineering Software 33, n^o 7-10 (juillet 2002) : 461–68. http://dx.doi.org/10.1016/s0965-9978(02)00048-0.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

19

Morris, Karla. « Emulating Multiple Inheritance in Fortran 2003/2008 ». Scientific Programming 2015 (2015) : 1–7. http://dx.doi.org/10.1155/2015/126069.

Texte intégral

Résumé :

Although the high-performance computing (HPC) community increasingly embraces object-oriented programming (OOP), most HPC OOP projects employ the C++ programming language. Until recently, Fortran programmers interested in mining the benefits of OOP had to emulate OOP in Fortran 90/95. The advent of widespread compiler support for Fortran 2003 now facilitates explicitly constructing object-oriented class hierarchies via inheritance and leveraging related class behaviors such as dynamic polymorphism. Although C++ allows a class to inherit from multiple parent classes, Fortran and several other OOP languages restrict or prohibit explicit multiple inheritance relationships in order to circumvent several pitfalls associated with them. Nonetheless, what appears as an intrinsic feature in one language can be modeled as a user-constructed design pattern in another language. The present paper demonstrates how to apply the facade structural design pattern to support a multiple inheritance class relationship in Fortran 2003. The design unleashes the power of the associated class relationships for modeling complicated data structures yet avoids the ambiguities that plague some multiple inheritance scenarios.

Styles APA, Harvard, Vancouver, ISO, etc.

20

Weissman, Jon B., Andrew S. Grimshaw et R. D. Ferraro. « Parallel Object-Oriented Computation Applied to a Finite Element Problem ». Scientific Programming 2, n^o 4 (1993) : 133–44. http://dx.doi.org/10.1155/1993/859092.

Texte intégral

Résumé :

The conventional wisdom in the scientific computing community is that the best way to solve large-scale numerically intensive scientific problems on today's parallel MIMD computers is to use Fortran or C programmed in a data-parallel style using low-level message-passing primitives. This approach inevitably leads to nonportable codes and extensive development time, and restricts parallel programming to the domain of the expert programmer. We believe that these problems are not inherent to parallel computing but are the result of the programming tools used. We will show that comparable performance can be achieved with little effort if better tools that present higher level abstractions are used. The vehicle for our demonstration is a 2D electromagnetic finite element scattering code we have implemented in Mentat, an object-oriented parallel processing system. We briefly describe the application. Mentat, the implementation, and present performance results for both a Mentat and a hand-coded parallel Fortran version.

Styles APA, Harvard, Vancouver, ISO, etc.

21

Hirsch, Michael. « h5fortran : object-oriented polymorphic Fortran interface for HDF5 file IO ». Journal of Open Source Software 6, n^o 62 (25 juin 2021) : 2842. http://dx.doi.org/10.21105/joss.02842.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

22

Filippone, Salvatore, et Alfredo Buttari. « Object-Oriented Techniques for Sparse Matrix Computations in Fortran 2003 ». ACM Transactions on Mathematical Software 38, n^o 4 (août 2012) : 1–20. http://dx.doi.org/10.1145/2331130.2331131.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

23

Blount, Brian, et Siddhartha Chatterjee. « An Evaluation of Java for Numerical Computing ». Scientific Programming 7, n^o 2 (1999) : 97–110. http://dx.doi.org/10.1155/1999/861637.

Texte intégral

Résumé :

This paper describes the design and implementation of high performance numerical software in Java. Our primary goals are to characterize the performance of object‐oriented numerical software written in Java and to investigate whether Java is a suitable language for such endeavors. We have implemented JLAPACK, a subset of the LAPACK library in Java. LAPACK is a high‐performance Fortran 77 library used to solve common linear algebra problems. JLAPACK is an object‐oriented library, using encapsulation, inheritance, and exception handling. It performs within a factor of four of the optimized Fortran version for certain platforms and test cases. When used with the native BLAS library, JLAPACK performs comparably with the Fortran version using the native BLAS library. We conclude that high‐performance numerical software could be written in Java if a handful of concerns about language features and compilation strategies are adequately addressed.

Styles APA, Harvard, Vancouver, ISO, etc.

24

Hamilton, Lisa, Mark Stalzer, R. Steven Turley, John Visher et Stephen Wandzura. « FastScatTM : An Object-Oriented Program for Fast Scattering Computation ». Scientific Programming 2, n^o 4 (1993) : 171–78. http://dx.doi.org/10.1155/1993/213747.

Texte intégral

Résumé :

FastScat is a state-of-the-art program for computing electromagnetic scattering and radiation. Its purpose is to support the study of recent algorithmic advancements, such as the fast multipole method, that promise speed-ups of several orders of magnitude over conventional algorithms. The complexity of these algorithms and their associated data structures led us to adopt an object-oriented methodology for FastScat. We discuss the program's design and several lessons learned from its C++ implementation including the appropriate level for object-orientedness in numeric software, maintainability benefits, interfacing to Fortran libraries such as LAPACK, and performance issues.

Styles APA, Harvard, Vancouver, ISO, etc.

25

Carr, M. « Using FORTRAN 90 and object-oriented programming to accelerate code development ». IEEE Antennas and Propagation Magazine 41, n^o 6 (1999) : 85–90. http://dx.doi.org/10.1109/74.815320.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

26

Qiang, Ji, Robert D. Ryne et Salman Habib. « Fortran implementation of object-oriented design in parallel beam dynamics simulations ». Computer Physics Communications 133, n^o 1 (décembre 2000) : 18–33. http://dx.doi.org/10.1016/s0010-4655(00)00165-x.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

27

Cary, John R., Svetlana G. Shasharina, Julian C. Cummings, John V. W. Reynders et Paul J. Hinker. « Comparison of C++ and Fortran 90 for object-oriented scientific programming ». Computer Physics Communications 105, n^o 1 (septembre 1997) : 20–36. http://dx.doi.org/10.1016/s0010-4655(97)00043-x.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

28

Yuan, Zifeng, et Jacob Fish. « Nonlinear multiphysics finite element code architecture in object oriented Fortran environment ». Finite Elements in Analysis and Design 99 (juillet 2015) : 1–15. http://dx.doi.org/10.1016/j.finel.2015.01.008.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

29

Doolin, David M., Jack Dongarra et Keith Seymour. « JLAPACK – Compiling LAPACK FORTRAN to Java ». Scientific Programming 7, n^o 2 (1999) : 111–38. http://dx.doi.org/10.1155/1999/179617.

Texte intégral

Résumé :

The JLAPACK project provides the LAPACK numerical subroutines translated from their subset Fortran 77 source into class files, executable by the Java Virtual Machine (JVM) and suitable for use by Java programmers. This makes it possible for Java applications or applets, distributed on the World Wide Web (WWW) to use established legacy numerical code that was originally written in Fortran. The translation is accomplished using a special purpose Fortran‐to‐Java (source‐to‐source) compiler. The LAPACK API will be considerably simplified to take advantage of Java’s object‐oriented design. This report describes the research issues involved in the JLAPACK project, and its current implementation and status.

Styles APA, Harvard, Vancouver, ISO, etc.

30

Kim, Yong-Hoon, In-Ho Lee et Richard M. Martin. « Object-oriented construction of a multigrid electronic-structure code with Fortran 90 ». Computer Physics Communications 131, n^o 1-2 (septembre 2000) : 10–25. http://dx.doi.org/10.1016/s0010-4655(00)00056-4.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

31

Decyk, Viktor K., et Henry J. Gardner. « Object-oriented design patterns in Fortran 90/95 : mazev1, mazev2 and mazev3 ». Computer Physics Communications 178, n^o 8 (avril 2008) : 611–20. http://dx.doi.org/10.1016/j.cpc.2007.11.013.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

32

Arabas, Sylwester, Dorota Jarecka, Anna Jaruga et Maciej Fijałkowski. « Formula Translation in Blitz++, NumPy and Modern Fortran : A Case Study of the Language Choice Tradeoffs ». Scientific Programming 22, n^o 3 (2014) : 201–22. http://dx.doi.org/10.1155/2014/870146.

Texte intégral

Résumé :

Three object-oriented implementations of a prototype solver of the advection equation are introduced. The presented programs are based on Blitz++ (C++), NumPy (Python) and Fortran's built-in array containers. The solvers constitute implementations of the Multidimensional Positive-Definite Advective Transport Algorithm (MPDATA). The introduced codes serve as examples for how the application of object-oriented programming (OOP) techniques and new language constructs from C++11 and Fortran 2008 allow to reproduce the mathematical notation used in the literature within the program code. A discussion on the tradeoffs of the programming language choice is presented. The main angles of comparison are code brevity and syntax clarity (and hence maintainability and auditability) as well as performance. All performance tests are carried out using free and open-source compilers. In the case of Python, a significant performance gain is observed when switching from the standard interpreter (CPython) to the PyPy implementation of Python. Entire source code of all three implementations is embedded in the text and is licensed under the terms of the GNU GPL license.

Styles APA, Harvard, Vancouver, ISO, etc.

33

DEGAWA, Tomohiro, et Yoshiyuki NAKAMICHI. « 0907 An Implementation of Vortex Method using Modern Fortran based on Object-Oriented Programming ». Proceedings of the Fluids engineering conference 2014 (2014) : _0907–1_—_0907–5_. http://dx.doi.org/10.1299/jsmefed.2014._0907-1_.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

34

QUINLAN, DAN. « ROSE : COMPILER SUPPORT FOR OBJECT-ORIENTED FRAMEWORKS ». Parallel Processing Letters 10, n^o 02n03 (juin 2000) : 215–26. http://dx.doi.org/10.1142/s0129626400000214.

Texte intégral

Résumé :

ROSE is a preprocessor generation tool for the support of compile time performance optimizations of general object-oriented frameworks. Within this work ROSE is being applied first to Overture, a serial/parallel object-oriented framework for solving partial differential equations in two and three space dimensions. The optimization of the interactions between objects within Overture is of particular interest since the Overture applications can be computationally large (many millions of mesh points and iterating over thousands of time-steps). Unfortunately, optimizations that might be obvious to the framework developer or application developer (e.g. cache based optimizations), due to the precise semantics of the framework's abstractions, are often lost through the C++ compiler's inability to recognize or leverage such semantics. Preprocessing steps can be used to introduce transformations using the semantics of a framework's abstractions, but the development of such a preprocessor tool is particularly complicated for a general object-oriented language such as C++. This paper shows how such framework specific preprocessors can be automatically generated. In this paper we briefly present Overture with some examples, and present our approach toward optimizing the performance for Overture and the A++P++ array class abstractions upon which Overture depends. The results we present show that the semantics of the abstractions represented within Overture and the A++P++ array class library can be used to generate a preprocessor using ROSE. The results demonstrate the performance of an Overture application with and without such a preprocessing step, the final performance with preprocessing is equivalent to that of optimized C and Fortran 77. By design, ROSE is general in its application to any object-oriented framework or application and is in no way specific to Overture.

Styles APA, Harvard, Vancouver, ISO, etc.

35

GUO, JIANG, et LUQI. « OBJECT MODELING TO RE-ENGINEER LEGACY SYSTEMS ». International Journal of Software Engineering and Knowledge Engineering 10, n^o 04 (août 2000) : 471–85. http://dx.doi.org/10.1142/s0218194000000225.

Texte intégral

Résumé :

This paper summarizes our experiences in using computer-supported methods to develop a software architecture to support the re-engineering of the Janus Combat Simulation System. We have analyzed the Janus FORTRAN source code, interviewed Janus domain experts, developed an object-oriented architecture for the Janus Combat Simulation subsystem, and validated the architecture with an executable prototype. In this paper, we propose methods to facilitate the evolution of the software component of these systems by recovering the behavior of the systems using systematic methods, and illustrate their use in the context of the Janus System.

Styles APA, Harvard, Vancouver, ISO, etc.

36

Bea, S. A., J. Carrera, C. Ayora, F. Batlle et M. W. Saaltink. « CHEPROO : A Fortran 90 object-oriented module to solve chemical processes in Earth Science models ». Computers & ; Geosciences 35, n^o 6 (juin 2009) : 1098–112. http://dx.doi.org/10.1016/j.cageo.2008.08.010.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

37

Radhakrishnan, Hari, Damian W. I. Rouson, Karla Morris, Sameer Shende et Stavros C. Kassinos. « Using Coarrays to Parallelize Legacy Fortran Applications : Strategy and Case Study ». Scientific Programming 2015 (2015) : 1–12. http://dx.doi.org/10.1155/2015/904983.

Texte intégral

Résumé :

This paper summarizes a strategy for parallelizing a legacy Fortran 77 program using the object-oriented (OO) and coarray features that entered Fortran in the 2003 and 2008 standards, respectively. OO programming (OOP) facilitates the construction of an extensible suite of model-verification and performance tests that drive the development. Coarray parallel programming facilitates a rapid evolution from a serial application to a parallel application capable of running on multicore processors and many-core accelerators in shared and distributed memory. We delineate 17 code modernization steps used to refactor and parallelize the program and study the resulting performance. Our initial studies were done using the Intel Fortran compiler on a 32-core shared memory server. Scaling behavior was very poor, and profile analysis using TAU showed that the bottleneck in the performance was due to our implementation of a collective, sequential summation procedure. We were able to improve the scalability and achieve nearly linear speedup by replacing the sequential summation with a parallel, binary tree algorithm. We also tested the Cray compiler, which provides its own collective summation procedure. Intel provides no collective reductions. With Cray, the program shows linear speedup even in distributed-memory execution. We anticipate similar results with other compilers once they support the new collective procedures proposed for Fortran 2015.

Styles APA, Harvard, Vancouver, ISO, etc.

38

Markus, Arjen. « Review of "Object-oriented Programming via Fortran 90/95 by Ed Akin." Cambridge University Press, 2003 ». ACM SIGPLAN Fortran Forum 22, n^o 2 (août 2003) : 7–8. http://dx.doi.org/10.1145/941558.941560.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

39

Ju, S. H. « OpenMp solvers for parallel finite element and meshless analyses ». Engineering Computations 31, n^o 1 (25 février 2014) : 2–17. http://dx.doi.org/10.1108/ec-02-2012-0032.

Texte intégral

Résumé :

Purpose – This paper develops C++ and Fortran-90 solvers to establish parallel solution procedures in a finite element or meshless analysis program using shared memory computers. The paper aims to discuss these issues. Design/methodology/approach – The stiffness matrix can be symmetrical or unsymmetrical, and the solution schemes include sky-line Cholesky and parallel preconditioned conjugate gradient-like methods. Findings – By using the features of C++ or Fortran-90, the stiffness matrix and its auxiliary arrays can be encapsulated into a class or module as private arrays. This class or module will handle how to allocate, renumber, assemble, parallelize and solve these complicated arrays automatically. Practical implications – The source codes can be obtained online at http//myweb.ncku.edu.tw/∼juju. The major advantage of the scheme is that it is simple and systematic, so an efficient parallel finite element or meshless program can be established easily. Originality/value – With the minimum requirement of computer memory, an object-oriented C++ class and a Fortran-90 module were established to allocate, renumber, assemble, parallel, and solve the global stiffness matrix, so that the programmer does not need to handle them directly.

Styles APA, Harvard, Vancouver, ISO, etc.

40

Rouson, Damian W. I. « Towards Analysis-Driven Scientific Software Architecture : The Case for Abstract Data Type Calculus ». Scientific Programming 16, n^o 4 (2008) : 329–39. http://dx.doi.org/10.1155/2008/393918.

Texte intégral

Résumé :

This article approaches scientific software architecture from three analytical paths. Each path examines discrete time advancement of multiphysics phenomena governed by coupled differential equations. The new object-oriented Fortran 2003 constructs provide a formal syntax for an abstract data type (ADT) calculus. The first analysis uses traditional object-oriented software design metrics to demonstrate the high cohesion and low coupling associated with the calculus. A second analysis from the viewpoint of computational complexity theory demonstrates that a more representative bug search strategy than that considered by Rouson et al. (ACM Trans. Math. Soft.34(1) (2008)) reduces the number of lines searched in a code with λ total lines from O(λ2) to O(λ log2λ ), which in turn becomes nearly independent of the overall code size in the context of ADT calculus. The third analysis derives from information theory an argument that ADT calculus simplifies developer communications in part by minimizing the growth in interface information content as developers add new physics to a multiphysics package.

Styles APA, Harvard, Vancouver, ISO, etc.

41

Viklund, Lars, et Peter Fritzson. « ObjectMath – An Object-Oriented Language and Environment for Symbolic and Numerical Processing in Scientific Computing ». Scientific Programming 4, n^o 4 (1995) : 229–50. http://dx.doi.org/10.1155/1995/829697.

Texte intégral

Résumé :

ObjectMath is a language for scientific computing that integrates object-oriented constructs with features for symbolic and numerical computation. Using ObjectMath, complex mathematical models may be implemented in a natural way. The ObjectMath programming environment provides tools for generating efficient numerical code from such models. Symbolic computation is used to rewrite and simplify equations before code is generated. One novelty of the ObjectMath approach is that it provides a comman language and an integrated environment for this kind of mixed symbolic/numerical computation. The motivation for this work is the current low-level state of the art in programming for scientific computing. Much numerical software is still being developed the traditional way in Fortran. This is especially true in application areas such as machine elements analysis, where complex nonlinear problems are the norm. We believe that tools like ObjectMath can increase productivity and quality, thus enabling users to solve problems that are too complex to handle with traditional tools.

Styles APA, Harvard, Vancouver, ISO, etc.

42

Zima, Hans P. « From FORTRAN 77 to Locality-Aware High Productivity Languages for Peta-Scale Computing ». Scientific Programming 15, n^o 1 (2007) : 45–65. http://dx.doi.org/10.1155/2007/219061.

Texte intégral

Résumé :

When the first specification of the FORTRAN language was released in 1956, the goal was to provide an "automatic programming system" that would enhance the economy of programming by replacing assembly language with a notation closer to the domain of scientific programming. A key issue in this context, explicitly recognized by the authors of the language, was the requirement to produce efficient object programs that could compete with their hand-coded counterparts. More than 50 years later, a similar situation exists with respect to finding the right programming paradigm for high performance computing systems. FORTRAN, as the traditional language for scientific programming, has played a major role in the quest for high-productivity programming languages that satisfy very strict performance constraints. This paper focuses on high-level support for locality awareness, one of the most important requirements in this context. The discussion centers on the High Performance Fortran (HPF) family of languages, and their influence on current language developments for peta-scale computing. HPF is a data-parallel language that was designed to provide the user with a high-level interface for programming scientific applications, while delegating to the compiler the task of generating an explicitly parallel message-passing program. We outline developments that led to HPF, explain its major features, identify a set of weaknesses, and discuss subsequent languages that address these problems. The final part of the paper deals with Chapel, a modern object-oriented language developed in the High Productivity Computing Systems (HPCS) program sponsored by DARPA. A salient property of Chapel is its general framework for the support of user-defined distributions, which is related in many ways to ideas first described in Vienna Fortran. This framework is general enough to allow a concise specification of sparse data distributions. The paper concludes with an outlook to future research in this area.

Styles APA, Harvard, Vancouver, ISO, etc.

43

Lin, J. W. B. « qtcm 0.1.2 : A Python Implementation of the Neelin-Zeng Quasi-Equilibrium Tropical Circulation model ». Geoscientific Model Development Discussions 1, n^o 1 (30 octobre 2008) : 315–44. http://dx.doi.org/10.5194/gmdd-1-315-2008.

Texte intégral

Résumé :

Abstract. Historically, climate models have been developed incrementally and in compiled languages like Fortran. While the use of legacy compiled languages results in fast, time-tested code, the resulting model is limited in its modularity and cannot take advantage of functionality available with modern computer languages. Here we describe an effort at using the open-source, object-oriented language Python to create more flexible climate models: the package qtcm, a Python implementation of the intermediate-level Neelin-Zeng Quasi-Equilibrium Tropical Circulation model (QTCM1) of the atmosphere. The qtcm package retains the core numerics of QTCM1, written in Fortran to optimize model performance, but uses Python structures and utilities to wrap the QTCM1 Fortran routines and manage model execution. The resulting "mixed language" modeling package allows order and choice of subroutine execution to be altered at run time, and model analysis and visualization to be integrated in interactively with model execution at run time. This flexibility facilitates more complex scientific analysis using less complex code than would be possible using traditional languages alone, and provides tools to transform the traditional "formulate hypothesis → write and test code → run model → analyze results" sequence into a feedback loop that can be executed automatically by the computer.

Styles APA, Harvard, Vancouver, ISO, etc.

44

Lin, J. W. B. « qtcm 0.1.2 : a Python implementation of the Neelin-Zeng Quasi-Equilibrium Tropical Circulation Model ». Geoscientific Model Development 2, n^o 1 (11 février 2009) : 1–11. http://dx.doi.org/10.5194/gmd-2-1-2009.

Texte intégral

Résumé :

Abstract. Historically, climate models have been developed incrementally and in compiled languages like Fortran. While the use of legacy compiled languages results in fast, time-tested code, the resulting model is limited in its modularity and cannot take advantage of functionality available with modern computer languages. Here we describe an effort at using the open-source, object-oriented language Python to create more flexible climate models: the package qtcm, a Python implementation of the intermediate-level Neelin-Zeng Quasi-Equilibrium Tropical Circulation model (QTCM1) of the atmosphere. The qtcm package retains the core numerics of QTCM1, written in Fortran to optimize model performance, but uses Python structures and utilities to wrap the QTCM1 Fortran routines and manage model execution. The resulting "mixed language" modeling package allows order and choice of subroutine execution to be altered at run time, and model analysis and visualization to be integrated in interactively with model execution at run time. This flexibility facilitates more complex scientific analysis using less complex code than would be possible using traditional languages alone, and provides tools to transform the traditional "formulate hypothesis → write and test code → run model → analyze results" sequence into a feedback loop that can be executed automatically by the computer.

Styles APA, Harvard, Vancouver, ISO, etc.

45

Attia, Ahmed, et Adrian Sandu. « DATeS : a highly extensible data assimilation testing suite v1.0 ». Geoscientific Model Development 12, n^o 2 (12 février 2019) : 629–49. http://dx.doi.org/10.5194/gmd-12-629-2019.

Texte intégral

Résumé :

Abstract. A flexible and highly extensible data assimilation testing suite, named DATeS, is described in this paper. DATeS aims to offer a unified testing environment that allows researchers to compare different data assimilation methodologies and understand their performance in various settings. The core of DATeS is implemented in Python and takes advantage of its object-oriented capabilities. The main components of the package (the numerical models, the data assimilation algorithms, the linear algebra solvers, and the time discretization routines) are independent of each other, which offers great flexibility to configure data assimilation applications. DATeS can interface easily with large third-party numerical models written in Fortran or in C, and with a plethora of external solvers.

Styles APA, Harvard, Vancouver, ISO, etc.

46

Papadimitriou, Stergios, Seferina Mavroudi, Kostas Theofilatos et Spiridon Likothanasis. « The Software Architecture for Performing Scientific Computation with the JLAPACK Libraries in ScalaLab ». Scientific Programming 20, n^o 4 (2012) : 379–91. http://dx.doi.org/10.1155/2012/247502.

Texte intégral

Résumé :

Although LAPACK is a powerful library its utilization is difficult. JLAPACK, a Java translation obtained automatically from the Fortran LAPACK sources, retains exactly the same difficult to use interface of LAPACK routines. The MTJ library implements an object oriented Java interface to JLAPACK that hides many complicated details. ScalaLab exploits the flexibility of the Scala language to present an even more friendly and convenient interface to the powerful but complicated JLAPACK library. The article describes the interfacing of the low-level JLAPACK routines within the ScalaLab environment. This is performed rather easily by exploiting well suited features of the Scala language. Also, the paper demonstrates the convenience of using JLAPACK routines for linear algebra operations from within ScalaLab.

Styles APA, Harvard, Vancouver, ISO, etc.

47

Morris, Karla, Damian W. I. Rouson, M. Nicole Lemaster et Salvatore Filippone. « Exploring Capabilities within ForTrilinos by Solving the 3D Burgers Equation ». Scientific Programming 20, n^o 3 (2012) : 275–92. http://dx.doi.org/10.1155/2012/378791.

Texte intégral

Résumé :

We present the first three-dimensional, partial differential equation solver to be built atop the recently released, open-source ForTrilinos package (http://trilinos.sandia.gov/packages/fortrilinos). ForTrilinos currently provides portable, object-oriented Fortran 2003 interfaces to the C++ packages Epetra, AztecOO and Pliris in the Trilinos library and framework [ACM Trans. Math. Softw.31(3) (2005), 397–423]. Epetra provides distributed matrix and vector storage and basic linear algebra calculations. Pliris provides direct solvers for dense linear systems. AztecOO provides iterative sparse linear solvers. We demonstrate how to build a parallel application that encapsulates the Message Passing Interface (MPI) without requiring the user to make direct calls to MPI except for startup and shutdown. The presented example demonstrates the level of effort required to set up a high-order, finite-difference solution on a Cartesian grid. The example employs an abstract data type (ADT) calculus [Sci. Program.16(4) (2008), 329–339] that empowers programmers to write serial code that lower-level abstractions resolve into distributed-memory, parallel implementations. The ADT calculus uses compilable Fortran constructs that resemble the mathematical formulation of the partial differential equation of interest.

Styles APA, Harvard, Vancouver, ISO, etc.

48

Hammond, Glenn E. « The PFLOTRAN Reaction Sandbox ». Geoscientific Model Development 15, n^o 4 (25 février 2022) : 1659–76. http://dx.doi.org/10.5194/gmd-15-1659-2022.

Texte intégral

Résumé :

Abstract. As modern reactive transport simulators evolve to accommodate the demands of a user community, researchers need a platform for prototyping new biogeochemical processes, many of which are niche and specific to laboratory or field experiments. The PFLOTRAN Reaction Sandbox leverages modern, object-oriented Fortran in an attempt to provide such an environment within an existing reactive transport simulator. This work describes the PFLOTRAN Reaction Sandbox concept and implementation through several illustrative examples. Reaction Sandbox Biodegradation Hill customizes the existing microbially mediated biodegradation reaction formulation within PFLOTRAN to better match empirical data. Reaction Sandbox Simple provides an isolated environment for testing numerous preconfigured kinetic rate expressions and developing user intuition. Reaction Sandbox Example serves as a template for creating new sandboxes within PFLOTRAN.

Styles APA, Harvard, Vancouver, ISO, etc.

49

DUMONT, JEAN-JACQUES, et MARCO TOMASSINI. « Portability and Reusability, Standardized Programming for Present and Future Computers ». International Journal of Modern Physics C 02, n^o 01 (mars 1991) : 39–57. http://dx.doi.org/10.1142/s0129183191000068.

Texte intégral

Résumé :

Unstructured sequential programming in Fortran, together with a top down approach for problem analysis, have always been and still are the usual physicists favorite methods as far as computing is concerned. This unfortunate fact of life is causing a tremendous amount of efficiency loss for code development and maintenance, which could easily be avoided by evolving to a more modern, bottom up programming style, based on the new emerging standards (system interfaces, communication between computational nodes, object-oriented C-extensions, user graphical interfaces, data structures etc.). We are reaching the historical point where this evolution becomes mandatory if one wants to tackle properly the problem of programming in a reasonably efficient way the highly parallel machines which are now appearing on the market, to the delight of numerous scientists who are badly in need of more computation power.

Styles APA, Harvard, Vancouver, ISO, etc.

50

Zaghi, S. « OFF, Open source Finite volume Fluid dynamics code : A free, high-order solver based on parallel, modular, object-oriented Fortran API ». Computer Physics Communications 185, n^o 7 (juillet 2014) : 2151–94. http://dx.doi.org/10.1016/j.cpc.2014.04.005.

Texte intégral

Styles APA, Harvard, Vancouver, ISO, etc.

Articles de revues sur le sujet « Object-oriented fortran »

Créez une référence correcte selon les styles APA, MLA, Chicago, Harvard et plusieurs autres