DOCSLIB.ORG

Modern Fortran Style and Usage

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Modern Fortran Style and Usage Modern Fortran Style and Usage Fortran is one of the oldest high-level languages and remains the premier language for writing code for science and engineering applications. Modern Fortran: Style and Usage is a book for anyone who uses Fortran, from the novice learner to the advanced expert. It describes best practices for programmers, scientists, engineers, computer scientists, and researchers who want to apply good style and incorporate rigorous usage in their own Fortran code or to establish guidelines for a team project. The presentation concentrates primarily on the characteristics of Fortran 2003, while also describing methods in Fortran 90/95 and valuable new features in Fortran 2008. The authors draw on more than a half century of experience writing produc- tion Fortran code to present clear succinct guidelines on formatting, naming, documenting, programming, and packaging conventions and various pro- gramming paradigms such as parallel processing (including OpenMP, MPI, and coarrays), OOP, generic programming, and C language interoperability. Programmers working with legacy code will especially appreciate the section on updating old programs. Norman S. Clerman is currently a private consultant. He was formerly the Chief Computer Scientist at Opcon Design Associates, LLC, a small company engaged in lens design. Walter Spector has been employed by Silicon Graphics International’s Profes- sional Services organization (formerly Cray Research Inc.) since 1984. http://ebooks.cambridge.org/ebook.jsf?bid=CBO9781139027687 Cambridge Books Online © Cambridge University Press, 2012 Reproduced with permission of IBM Corporate Archives http://ebooks.cambridge.org/ebook.jsf?bid=CBO9781139027687 Cambridge Books Online © Cambridge University Press, 2012 Modern Fortran Style and Usage Norman S. Clerman Walter Spector Silicon Graphics, Inc., Fremont, California http://ebooks.cambridge.org/ebook.jsf?bid=CBO9781139027687 Cambridge Books Online © Cambridge University Press, 2012 cambridge university press Cambridge, New York, Melbourne, Madrid, Cape Town, Singapore, Sao˜ Paulo, Delhi, Tokyo, Mexico City Cambridge University Press 32 Avenue of the Americas, New York, NY 10013-2473, USA www.cambridge.org Information on this title: www.cambridge.org/9780521730525 c Norman S. Clerman and Walter Spector 2012 This publication is in copyright. Subject to statutory exception and to the provisions of relevant collective licensing agreements, no reproduction of any part may take place without the written permission of Cambridge University Press. First published 2012 Printed in the United States of America A catalog record for this publication is available from the British Library. Library of Congress Cataloging in Publication data Clerman, Norman S., 1946– Modern Fortran : style and usage / Norman S. Clerman, Walter Spector. p. cm. Includes bibliographical references and index. ISBN 978-0-521-51453-8 (hardback) 1. FORTRAN (Computer program language) I. Spector, Walter, 1956– II. Title. QA76.73.F25C56 2012 005.133 – dc23 2011026625 ISBN 978-0-521-51453-8 Hardback ISBN 978-0-521-73052-5 Paperback Cambridge University Press has no responsibility for the persistence or accuracy of URLs for external or third-party Internet Web sites referred to in this publication and does not guarantee that any content on such Web sites is, or will remain, accurate or appropriate. http://ebooks.cambridge.org/ebook.jsf?bid=CBO9781139027687 Cambridge Books Online © Cambridge University Press, 2012 To Miriam for all her love and endless encouragement. Norman S. Clerman To Irene, Nyssa, Simon, and Sammy with love. Walter Spector http://ebooks.cambridge.org/ebook.jsf?bid=CBO9781139027687 Cambridge Books Online © Cambridge University Press, 2012 http://ebooks.cambridge.org/ebook.jsf?bid=CBO9781139027687 Cambridge Books Online © Cambridge University Press, 2012 Contents SourceCodeListings..............................................page xi Preface.............................................................xiii Audience........................................................xiii GeneralConsiderations............................................xiii Organization.....................................................xiv 1. Introduction .................................................. 1 1.1 Acknowledgments............................................1 1.2 TypographicalConventions....................................1 1.3 SourceCodeListings..........................................2 2. General Principles........................................... 3 3. Formatting Conventions .................................... 9 3.1 SourceForm.................................................9 3.2 Case.......................................................10 3.3 Indentation.................................................13 3.4 WhiteSpace................................................17 3.5 StatementsandExpressions...................................20 3.6 SymbolsandNumbers.......................................22 4. Naming Conventions ...................................... 24 4.1 Modules,Procedures,andTypes...............................24 4.2 SupplementalNotation.......................................27 4.3 DataObjects................................................30 4.4 ConstructBlocks............................................34 5. Documentation Conventions ............................. 38 6. Programming Principles ................................... 44 6.1 StandardsConformance......................................44 6.2 ModuleDesign..............................................44 6.3 ProcedureArguments........................................50 6.4 ArgumentVerification........................................82 6.5 RecursiveProcedureDesign...................................86 6.6 State,SideEffects,andThreadSafety...........................90 vii http://ebooks.cambridge.org/ebook.jsf?bid=CBO9781139027687 Cambridge Books Online © Cambridge University Press, 2012 viii CONTENTS 7. Programming Conventions................................ 98 7.1 DeclarationandInitializationofDataObjects...................98 7.2 AllocatableandPointerAttributes............................102 7.3 DynamicDataAttributes....................................128 7.4 ControlFlow..............................................133 7.5 CharacterStringExpressions.................................138 8. Input and Output.......................................... 140 8.1 GeneralI/OOperations.....................................140 8.2 Formatted,Unformatted,andStreamI/O......................155 8.3 Messages..................................................163 9. Packaging Conventions.................................. 165 9.1 Files......................................................165 9.2 ExternalProcedures.........................................165 9.3 Submodules...............................................167 10. Generic Programming .................................... 171 10.1 GenericCodeTechniques..................................172 10.2 PreprocessorReplication....................................179 11. Object Orientation ........................................ 183 11.1 TypeandClassDesign.....................................184 11.2 Creation, Construction, Initialization, and Assignment .........189 11.3 Type-Bound Procedures and Procedure Pointer Components . 197 11.4 Inheritance...............................................208 11.5 Polymorphism............................................212 12. Parallel Processing ....................................... 216 12.1 PreliminaryConsiderations.................................217 12.2 ParallelProgramPatterns...................................220 12.3 Fortran 2008 Parallel Processing . .........................242 13. Numerical Types, Kinds, and Operations ............... 247 13.1 TheConceptofKIND.....................................247 13.2 Floating-PointOperations..................................249 13.3 Floating-PointExceptions..................................253 13.4 BitManipulation..........................................258 14. C Interoperability ......................................... 262 15. Updating Old Programs .................................. 271 15.1 Statements................................................271 15.2 Techniques...............................................282 15.3 NonstandardFeatures......................................284 http://ebooks.cambridge.org/ebook.jsf?bid=CBO9781139027687 Cambridge Books Online © Cambridge University Press, 2012 CONTENTS ix A. Source Code ........................................... 289 A.1 Type bound demo.........................................289 A.2 Unlimited demo...........................................295 B. Rule List ................................................. 308 Bibliography . .......................................................321 Index..............................................................327 http://ebooks.cambridge.org/ebook.jsf?bid=CBO9781139027687 Cambridge Books Online © Cambridge University Press, 2012 http://ebooks.cambridge.org/ebook.jsf?bid=CBO9781139027687 Cambridge Books Online © Cambridge University Press, 2012 Source Code Listings 6.1 Program Intent exp imp ........................................50 6.2 Program Intent out test .......................................57 6.3 Program Point intent in out ...................................67 6.4 Program Arg par test ..........................................83 7.1 Program Return string ........................................111
Load more

Recommended publications
  • Inf 212 Analysis of Prog. Langs Elements of Imperative Programming Style
    INF 212 ANALYSIS OF PROG. LANGS ELEMENTS OF IMPERATIVE PROGRAMMING STYLE Instructors: Kaj Dreef Copyright © Instructors. Objectives Level up on things that you may already know… ! Machine model of imperative programs ! Structured vs. unstructured control flow ! Assignment ! Variables and names ! Lexical scope and blocks ! Expressions and statements …so to understand existing languages better Imperative Programming 3 Oldest and most popular paradigm ! Fortran, Algol, C, Java … Mirrors computer architecture ! In a von Neumann machine, memory holds instructions and data Control-flow statements ! Conditional and unconditional (GO TO) branches, loops Key operation: assignment ! Side effect: updating state (i.e., memory) of the machine Simplified Machine Model 4 Registers Code Data Stack Program counter Environment Heap pointer Memory Management 5 Registers, Code segment, Program counter ! Ignore registers (for our purposes) and details of instruction set Data segment ! Stack contains data related to block entry/exit ! Heap contains data of varying lifetime ! Environment pointer points to current stack position ■ Block entry: add new activation record to stack ■ Block exit: remove most recent activation record Control Flow 6 Control flow in imperative languages is most often designed to be sequential ! Instructions executed in order they are written ! Some also support concurrent execution (Java) But… Goto in C # include <stdio.h> int main(){ float num,average,sum; int i,n; printf("Maximum no. of inputs: "); scanf("%d",&n); for(i=1;i<=n;++i){
    [Show full text]
  • Jalopy User's Guide V. 1.9.4
    Jalopy - User’s Guide v. 1.9.4 Jalopy - User’s Guide v. 1.9.4 Copyright © 2003-2010 TRIEMAX Software Contents Acknowledgments . vii Introduction . ix PART I Core . 1 CHAPTER 1 Installation . 3 1.1 System requirements . 3 1.2 Prerequisites . 3 1.3 Wizard Installation . 4 1.3.1 Welcome . 4 1.3.2 License Agreement . 5 1.3.3 Installation Features . 5 1.3.4 Online Help System (optional) . 8 1.3.5 Settings Import (optional) . 9 1.3.6 Configure plug-in Defaults . 10 1.3.7 Confirmation . 11 1.3.8 Installation . 12 1.3.9 Finish . 13 1.4 Silent Installation . 14 1.5 Manual Installation . 16 CHAPTER 2 Configuration . 17 2.1 Overview . 17 2.1.1 Preferences GUI . 18 2.1.2 Settings files . 29 2.2 Global . 29 2.2.1 General . 29 2.2.2 Misc . 32 2.2.3 Auto . 35 2.3 File Types . 36 2.3.1 File types . 36 2.3.2 File extensions . 37 2.4 Environment . 38 2.4.1 Custom variables . 38 2.4.2 System variables . 40 2.4.3 Local variables . 41 2.4.4 Usage . 42 2.4.5 Date/Time . 44 2.5 Exclusions . 44 2.5.1 Exclusion patterns . 45 2.6 Messages . 46 2.6.1 Categories . 47 2.6.2 Logging . 48 2.6.3 Misc . 49 2.7 Repository . 49 2.7.1 Searching the repository . 50 2.7.2 Displaying info about the repository . 50 2.7.3 Adding libraries to the repository . 50 2.7.4 Removing the repository .
    [Show full text]
  • C Style and Coding Standards
    -- -- -1- C Style and Coding Standards Glenn Skinner Suryakanta Shah Bill Shannon AT&T Information System Sun Microsystems ABSTRACT This document describes a set of coding standards and recommendations for programs written in the C language at AT&T and Sun Microsystems. The purpose of having these standards is to facilitate sharing of each other’s code, as well as to enable construction of tools (e.g., editors, formatters). Through the use of these tools, programmers will be helped in the development of their programs. This document is based on a similar document written by L.W. Cannon, R.A. Elliott, L.W. Kirchhoff, J.H. Miller, J.M. Milner, R.W. Mitze, E.P. Schan, N.O. Whittington at Bell Labs. -- -- -2- C Style and Coding Standards Glenn Skinner Suryakanta Shah Bill Shannon AT&T Information System Sun Microsystems 1. Introduction The scope of this document is the coding style used at AT&T and Sun in writing C programs. A common coding style makes it easier for several people to cooperate in the development of the same program. Using uniform coding style to develop systems will improve readability and facilitate maintenance. In addition, it will enable the construction of tools that incorporate knowledge of these standards to help programmers in the development of programs. For certain style issues, such as the number of spaces used for indentation and the format of variable declarations, no clear consensus exists. In these cases, we have documented the various styles that are most frequently used. We strongly recommend, however, that within a particular project, and certainly within a package or module, only one style be employed.
    [Show full text]
  • A Description of One Programmer's Programming Style Revisited
    A Description of One Programmer’s Programming Style Revisited Adam N. Rosenberg 1990 August 1 2001 October 1 ABSTRACT We present the outlook of a programmer at AT&T Bell Labs who has written much code during his eight years there and thirteen years in other places. This document describes the author’s own programming style and what he considers important in generating reli- able, readable, and maintainable code. Since this document is the opinions and prejudices of an individual, it is written in the first person in a conversational tone, and with subjects covered in no particular order. It is intended to be a repository of good questions rather than a source of answers. The author feels that many programmers suffer from gross inattention to detail in writing code. He suggests that clarity and consistency will be rewarded sooner than most people think. A veteran of many languages and operating systems, the author today finds himself using the MS-DOS and UNIXr operating systems and the FORTRAN and C languages. The examples here are all either FORTRAN or C. A decade later the author feels that programming productivity in our “post modern” world has decreased sharply from 1990 to 2000. Many of the reasons for this decline were discussed in the original version of this paper. Our pleasure in prescient prognostication is mitigated by frustration with the “dumbing down” of computing in general. Based on this unhappy downturn of programming education and style, we have added materal (in italics) emphasizing areas of recent concern. The original text and examples (still in regular type) have been left virtually intact.
    [Show full text]
  • Comparative Studies of 10 Programming Languages Within 10 Diverse Criteria Revision 1.0
    Comparative Studies of 10 Programming Languages within 10 Diverse Criteria Revision 1.0 Rana Naim∗ Mohammad Fahim Nizam† Concordia University Montreal, Concordia University Montreal, Quebec, Canada Quebec, Canada [email protected] [email protected] Sheetal Hanamasagar‡ Jalal Noureddine§ Concordia University Montreal, Concordia University Montreal, Quebec, Canada Quebec, Canada [email protected] [email protected] Marinela Miladinova¶ Concordia University Montreal, Quebec, Canada [email protected] Abstract This is a survey on the programming languages: C++, JavaScript, AspectJ, C#, Haskell, Java, PHP, Scala, Scheme, and BPEL. Our survey work involves a comparative study of these ten programming languages with respect to the following criteria: secure programming practices, web application development, web service composition, OOP-based abstractions, reflection, aspect orientation, functional programming, declarative programming, batch scripting, and UI prototyping. We study these languages in the context of the above mentioned criteria and the level of support they provide for each one of them. Keywords: programming languages, programming paradigms, language features, language design and implementation 1 Introduction Choosing the best language that would satisfy all requirements for the given problem domain can be a difficult task. Some languages are better suited for specific applications than others. In order to select the proper one for the specific problem domain, one has to know what features it provides to support the requirements. Different languages support different paradigms, provide different abstractions, and have different levels of expressive power. Some are better suited to express algorithms and others are targeting the non-technical users. The question is then what is the best tool for a particular problem.
    [Show full text]
  • DSS: C/C++ Programming Style Guidelines
    C/C++ Programming Style Guidelines C/C++ Programming Style Guidelines Table of Contents Introduction File Contents File Format Choosing Meaningful Names Comments Syntax and Language Issues Conclusion Appendix A. Review Checklist References De gustibus non est disputandum. Introduction This document contains the guidelines for writing C/C++ code for Dynamic Software Solutions. The point of a style guide is to greater uniformity in the appearance of source code. The benefit is enhanced readability and hence maintainability for the code. Wherever possible, we adopt stylistic conventions that have been proved to contribute positively to readability and/or maintainability. Before code can be considered for peer review the author must check that it adheres to these guidelines. This may be considered a prerequisite for the review process. A checklist is provided at the end of this document to aid in validating the source code's style. Where code fails to adhere to the conventions prescribed here may be considered a defect during the review process. If you have not already, please study Code Complete by Steve McConnell. This book provides a detailed discussion on all things related to building software systems. It also includes references to statistical studies on many of the stylistic elements that affect program maintainability. Another valuable source of solid programming practice tips is The Practice of Programming by Brian W. Kernighan and Rob Pike. Scott Meyers' books, Effective C++ and More Effective C++ should be considered required reading for any C++ programmer. And what person would be considered complete without having read The Elements of Style by Strunk and White? References The C++ Programming Language, Bjarne Stroustrup, 0-201-88954-4, Addison-Wesley, 1997.
    [Show full text]
  • Javascript Code Quality Analysis
    JavaScript Code Quality Analysis Master’s Thesis Joost-Wim Boekesteijn JavaScript Code Quality Analysis THESIS submitted in partial fulfillment of the requirements for the degree of MASTER OF SCIENCE in COMPUTER SCIENCE by Joost-Wim Boekesteijn born in Hoogeveen, the Netherlands Software Engineering Research Group m-industries Department of Software Technology M-Industries BV Faculty EEMCS, Delft University of Technology Rotterdamseweg 183c Delft, the Netherlands Delft, the Netherlands www.ewi.tudelft.nl www.m-industries.com c 2012 Joost-Wim Boekesteijn. JavaScript Code Quality Analysis Author: Joost-Wim Boekesteijn Student id: 1174355 Email: [email protected] Abstract Static analysis techniques provide a means to detect software errors early in the development process, without actually having to run the software that is being analyzed. These techniques are common for statically typed languages and have found their way into IDEs such as Eclipse and Visual Studio. However, applying the same techniques to dynamically typed languages is much less common. Tool support is less mature and the amount of published research is relatively small. For this project, we design and build a static analyis tool for JavaScript code. We start by giving background information on relevant parts of the JavaScript language, followed by a survey of existing tools and research. In the design of our analysis tool, we achieved a clear separation of responsibilities between the different modules for parsing, analysis, rule definition and reporting. The level of detail in the default reporter makes our tool an ideal candidate for integration in a JavaScript IDE. On the other hand, our tool is also suited for batch analysis of large code collections.
    [Show full text]
  • How Developers Engage with Static Analysis Tools in Different Contexts
    Noname manuscript No. (will be inserted by the editor) How Developers Engage with Static Analysis Tools in Different Contexts Carmine Vassallo · Sebastiano Panichella · Fabio Palomba · Sebastian Proksch · Harald C. Gall · Andy Zaidman This is an author-generated version. The final publication will be available at Springer. Abstract Automatic static analysis tools (ASATs) are instruments that sup- port code quality assessment by automatically detecting defects and design issues. Despite their popularity, they are characterized by (i) a high false positive rate and (ii) the low comprehensibility of the generated warnings. However, no prior studies have investigated the usage of ASATs in different development contexts (e.g., code reviews, regular development), nor how open source projects integrate ASATs into their workflows. These perspectives are paramount to improve the prioritization of the identified warnings. To shed light on the actual ASATs usage practices, in this paper we first survey 56 developers (66% from industry and 34% from open source projects) and inter- view 11 industrial experts leveraging ASATs in their workflow with the aim of understanding how they use ASATs in different contexts. Furthermore, to in- vestigate how ASATs are being used in the workflows of open source projects, we manually inspect the contribution guidelines of 176 open-source systems and extract the ASATs' configuration and build files from their corresponding GitHub repositories. Our study highlights that (i) 71% of developers do pay attention to different warning categories depending on the development con- text; (ii) 63% of our respondents rely on specific factors (e.g., team policies and composition) when prioritizing warnings to fix during their programming; and (iii) 66% of the projects define how to use specific ASATs, but only 37% enforce their usage for new contributions.
    [Show full text]
  • Software Engineer [email protected] - 720-565-1569
    Gabriel Perry – Software Engineer [email protected] - 720-565-1569 SUMMARY Software Engineer living in Boulder, Colorado with 17+ years of experience in software development in multiple environments with a focus on web technologies. Strong analytic and problem-solving skills, self- motivated, detail-oriented, creative, open-minded, and friendly. Writing maintainable, readable, and well- documented code is a passion. PROFESSIONAL EXPERIENCE VCA Animal Hospitals, Westminster, CO, (9/2018 – Present) Software Engineer - Camp Bow Wow Software development using Angular/Typescript for Camp Bow Wow, a leading doggy daycare and boarding franchise with 150+ locations across the United States. Technologies Used: Typescript, Angular 6/7/8/9, NgRx, RxJS, Jasmine, Karma, Angular Flex Layout, Angular Material, CSS/Sass. Dev Platform: MacBook Pro, Linux. Tools: PhpStorm, WebStorm, Chrome, Git, Bitbucket, Sourcetree, Insomnia, MySQL Workbench, and Jira. New feature and maintenance development in a highly collaborative, fast paced, agile environment. Significant system refactorizations and improvements: Payments, Invoices, Reports, internal libraries/utilities. Massive endpoint/API integrations/updates in support of significant database and endpoint/API upgrades. Removing NgRx layer and replacing it with direct backend API calls. Advocated for the overall improvement of code quality, development processes and (written) communication for the Frontend team. o Designed a Typescript and Angular programming style-guide which was adopted by the Frontend development team. o Advocated for and helped the team adopt regular code-reviews using Bitbucket. o Encouraged the team to write more unit tests, especially for the tricky parts of the code. o Worked with management to help refine their Agile/Scrum development life-cycle. o Encouraged dev team to be more disciplined regarding code and process documentation as well as design specs/artifacts.
    [Show full text]
  • Elements of Programming Style
    THE ELEMENTS OF PROGRAMMING STYLE SECOND EDITION Kernighan and Plauger THE ELEMENTS OF PROGRAMMING STYLE Second Edition Brian W. Kernighan Bell laboratories Murray Hill, New Jersey P. J. Plauger Yourdon, Inc. New York, New York McGRAW-HILL BOOK COMPANY New York St. Lou1; San Franc1;co Auckland Bogota Du;seldorf London Madnd Mexico Montreal New Delhi Panama Pan' Sao Paulo Singapore Sydney Tokyo Toronto Library of Congress Cataloging in Publication Data Kernighan, Brian W. The elements of programming style. Bibliography: p. Includes index. I. Electronic digital computers-Programming. I. Plauger, P.J., date joint author. II. Title. QA 76.6.K47 1978 001.6'42 78-3498 ISBN 0-07-034207-5 The Elements of Programming Style Copyright © 1978, 1974 by Bell Telephone Laboratories, Incorporated. All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by any means, electronic, mechanical, photocopy­ ing, recording, or otherwise, without the prior written permission of Bell Laboratories. Printed in the United States of America. 12 13 14 15 DODO 8 9 This book was set in Times Roman and Courier 12 by the authors, using a Graphic Sys­ tems phototypesetter driven by a PDP-11/70 running under the UNIX operating system. UNIX is a Trademark of Bell Laboratories. We are deeply indebted to the following authors and publishers for their kind permission to reproduce excerpts from the following copyrighted material: R V Andree, J P Andree, and D D Andree, Computer Programmmg Techniques, A nalys1s, and Mathematics. Copyright © 1973 by R V Andree By permission of Prentice-Hall, Inc F Bates and M L Douglas, Programmmg Language/One with Structured Programming (Thtrd Edmon) Copyright © 1975 by Prentice-Hall, Inc Reprinted by permission C R Bauer and A P Peluso, Basic Fortran IV with Waifor & Wa(/iv.
    [Show full text]
  • Self-Study Guide 2: Programming in Fortran 95
    University of Cambridge Department of Physics Computational Physics Self-study guide 2 Programming in Fortran 95 Dr. Rachael Padman Michaelmas 2007 Contents 1. THE BASICS 3 1.1 A very simple program 3 1.2 Running the program 4 1.3 Variables and expressions 5 1.4 Other variable types: integer, complex and character 8 1.5 Intrinsic functions 11 1.6 Logical controls 13 1.7 Advanced use of if and logical comparisons 15 1.8 Repeating ourselves with loops: do 16 1.9 The stop statement 17 1.10 Arrays 17 1.11 Array arithmetic 19 2 GOOD PROGRAMMING STYLE 21 2.1 Readability 21 2.2 Self-checking code 22 2.3 Write clear code that relates to the physics 22 3. INPUT TO AND OUTPUT FROM A F95 PROGRAM 24 3.1 F95 statements for I/O 24 4 GRAPHICS AND VISUALISATION 27 4.1 Plotting a data file 27 4.2 Getting help 28 4.3 Further examples 28 4.4 Printing graphs into PostScript files 29 SUGGESTED EXERCISE 1 30 5. PROGRAM ORGANISATION: FUNCTIONS AND SUBROUTINES 31 5.1 Functions 31 5.2 Formal definition 33 5.3 Subroutines 34 5.4 Local and global variables 34 5.5 Passing arrays to subroutines and functions 35 5.5.1 Size and shape of array known 35 5.5.2 Arrays of unknown shape and size 35 5.6 The intent and save attributes 36 6. USING MODULES 38 6.1 Modules 38 6.2 public and private attributes 41 7 NUMERICAL PRECISION AND MORE ABOUT VARIABLES 42 7.1 Entering numerical values 42 7.2 Numerical Accuracy 42 1 8 USE OF NUMERICAL LIBRARIES: NAG 44 8.1 A simple NAG example 44 8.2 A non-trivial NAG example: matrix determinant 44 9 SOME MORE TOPICS 47 9.1 The case statement and more about if 47 9.2 Other forms of do loops 48 SUGGESTED EXERCISE 2 49 Acknowledgements: This handout was originally prepared by Dr.
    [Show full text]
  • Comparing LISP and Object-Oriented Programming Languages
    Wang 1 Pengfei Wang Professor Christopher A. Healy Computer Science 475 11 April 2016 Compare LISP with Object-Oriented Programming Languages Introduction LISP, which stands for List Processor, is a family of functional programming languages, invented by John McCarthy in MIT based on Lambda Calculus in 1958. It is the second-oldest high-level programming language and it was originally designed for Artificial Intelligence, but it is a good general-purpose language as well. This paper is going to discuss the differences between LISP and Object-Oriented Languages, focusing mainly on LISP. This paper is going to firstly introduce functional programming language and LISP. Then, advantages and disadvantages of LISP comparing to object-oriented languages will be discussed, and finally a specific case study will be done. Functional Programming Languages and List Processor Typically, programming languages are divided into two general types, imperative languages and declarative languages. The computer program written in imperative languages consists of statements, instructions, which indicate how (and in what order) a computation should be done. Imperative languages include all of the object-oriented languages. On the other hand, declarative languages define functions, formulas or relationships. Declarative languages do not specify how the functions are performed step-by-step in program. Functional Wang 2 programming language is one type of the declarative languages. ;; Example: Written in Common LISP (format t “Result: ~A.~%” (* 2 (+ 2 3))) ; functions /* Example: Written in C*/ int a = 2 + 3; /*statement*/ int b = a * 2; /*statement*/ printf("Result: %d.\n", b); /*statement*/ Function languages employ a computational model based on the recursive definition of functions.
    [Show full text]