DOCSLIB.ORG

Learning Computer Programming with Ch for the Absolute Beginner

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Learning Computer Programming with Ch for the Absolute Beginner Learning Computer Programming with Ch for the Absolute Beginner Harry H. Cheng UC Davis Center for Integrated Computing and STEM Education (C-STEM) University of California-Davis http://c-stem.ucdavis.edu Copyright ⃝c June, 2016 by Harry H. Cheng, All rights reserved. No part of this publication may be reproduced or distributed in any form or by any means, or stored in a database or retrieval system, without the prior written consent of the author, including, but not limited to, in any network or other electronic storage or transmission, or broadcast for distance learning. Table of Contents Preface vii 1 Getting Started with the First Ch Program 1 1.1 Introduction ........................................... 1 1.2 Getting Started with ChIDE ................................... 2 1.2.1 The First Ch Program ................................. 2 1.2.2 Opening Programs in ChIDE from Windows Explorer ................ 3 1.2.3 Editing Programs .................................... 3 1.2.4 Running Programs and Stopping Their Execution ................... 4 1.2.5 Output from Execution of Programs .......................... 4 1.2.6 Correcting Errors in Programs ............................. 5 1.2.7 Browsing Files ..................................... 5 1.3 Executing Programming Statements and Expressions in Ch .................. 7 1.3.1 Interactive Execution of Programming Statements and Expressions ......... 8 1.3.2 Repeating Commands in Ch Command Window ................... 8 1.4 Documentation about ChIDE and Ch Command Window ................... 9 1.5 Chapter Summary ........................................ 9 1.5.1 Programming Tips ................................... 9 1.5.2 Terminology ...................................... 10 1.6 Exercises ............................................ 10 2 Variables, Data Types, and Input/Output 12 2.1 Commonly Used Data Types and Declaration of Variables .................. 12 2.1.1 Declaration of Variables and Integral Type int ..................... 13 2.1.2 Initialization ...................................... 14 2.1.3 Floating-Point Numbers and Type double ....................... 14 2.1.4 Strings ......................................... 16 2.2 Formatted Input and Output ................................... 17 2.2.1 The Output Function printf() ............................. 17 iii 2.2.2 The Input Function scanf() ............................... 21 2.3 Structures of a Program for Solving Applied Problems .................... 24 2.3.1 Copying Contents in a Program to Create a New Program in ChIDE ......... 26 2.4 Debugging Programs in ChIDE ................................. 27 2.4.1 Executing Programs in Debug Mode .......................... 28 2.4.2 Monitoring Local Variables and Their Values in the Debug Pane ........... 28 2.4.3 Changing Values of Variables in the Debug Command Pane ............. 28 2.5 Chapter Summary ........................................ 30 2.5.1 Programming Tips ................................... 30 2.5.2 Terminology ...................................... 32 2.6 Exercises ............................................ 32 3 Operators and Expressions 34 3.1 Expressions ........................................... 34 3.2 Assignment Operator ...................................... 35 3.3 Arithmetic Operators ...................................... 35 3.4 Precedence and Associativity of Operators ........................... 38 3.5 Exponential Expressions and Square Root ........................... 41 3.6 Chapter Summary ........................................ 42 3.6.1 Programming Tips ................................... 42 3.6.2 Terminology ...................................... 43 3.7 Exercises ............................................ 43 4 Graphical Visualization 46 4.1 Plotting Points for Scatter Plots and Trend Lines ........................ 46 4.1.1 Copying and Printing Plots ............................... 48 4.2 Plotting Lines Using Two Points ................................ 49 4.3 Plotting Expressions ...................................... 51 4.4 Obtaining the Coordinates for Points on a Plot ......................... 52 4.5 Plotting Rectangles, Squares, and Circles ........................... 53 4.6 Setting Axis Ranges and Tick Marks in Plots ......................... 55 4.7 Plotting Multiple Lines and Curves in a Single Graph ..................... 57 4.8 Setting Stroke Color and Width, Line and Point Styles .................... 59 4.8.1 Setting Stroke Color and Width ............................ 59 4.8.2 Setting Line Style .................................... 59 4.8.3 Setting Point Style ................................... 59 4.9 Filling Objects with Colors ................................... 63 4.10 Plotting Texts and Arrows ................................... 65 4.11 Saving Plot in a File ....................................... 66 4.12 Chapter Summary ........................................ 68 4.12.1 Programming Tips ................................... 68 4.12.2 Terminology ...................................... 68 4.13 Exercises ............................................ 69 iv 5 Relations and Making Decisions 74 5.1 Relational Operators ...................................... 74 5.2 Selection Statements for Decision Making ........................... 77 5.2.1 The if Statement .................................... 77 5.2.2 The if-else Statement .................................. 77 5.2.3 Debugging Programs with Selection Statements Using ChIDE ............ 79 5.2.4 Programming Style and Indenting Programs Using ChIDE .............. 80 5.3 Logical Operators ........................................ 80 5.4 The else if Selection Statement and Early Exit of a Program .................. 85 5.5 Chapter Summary ........................................ 86 5.5.1 Programming Tips ................................... 86 5.5.2 Terminology ...................................... 90 5.6 Exercises ............................................ 90 6 Loops for Repetition and Random Numbers 93 6.1 The while Loop ......................................... 93 6.2 Debugging Programs with Repetition Statements Using ChIDE ................ 94 6.3 Increment and Decrement Operators .............................. 95 6.4 Control of Repetition ...................................... 95 6.4.1 Counter-Controlled Repetition ............................. 95 6.4.2 Sentinel-Controlled Repetition ............................. 98 6.5 The for Loop .......................................... 100 6.6 Formatting Output with a Specified Field Width ........................ 102 6.7 The break Statement ...................................... 104 6.8 Random Number Generation .................................. 105 6.9 Chapter Summary ........................................ 110 6.9.1 Programming Tips ................................... 110 6.9.2 Terminology ...................................... 111 6.10 Exercises ............................................ 111 7 Modular Programming with Functions 118 7.1 Function Definitions ...................................... 118 7.2 Debugging Programs with Functions in ChIDE ........................ 121 7.3 Functions for Mathematical Formulas ............................. 123 7.4 Functions without Arguments or Return Values ........................ 124 7.5 Plotting Functions for Graphical Display ............................ 127 7.5.1 Plotting a Curve Using the Member Function func2D() ................ 127 7.5.2 Zooming in to Find the Coordinates of a Point on a Plot ............... 128 7.5.3 Plotting Multiple Curves Using Different Functions in a Single Plot ......... 131 7.5.4 Plotting a Scatter Plot Using the Member Function func2DPoint() .......... 131 7.5.5 Filling an Area with Color ............................... 133 7.6 Passing Arguments of Function by References ......................... 136 7.6.1 z Solving Quadratic Equations ............................. 138 7.7 zMathematical Functions in the Standard C Library ...................... 139 7.8 Chapter Summary ........................................ 141 7.8.1 Programming Tips ................................... 141 v 7.8.2 Terminology ...................................... 141 7.9 Exercises ............................................ 142 8 Arrays for Data Processing 147 8.1 Declaration, Reference, Input, and Output for Arrays ..................... 147 8.2 How Arrays Are Stored in Memory .............................. 149 8.3 Initialization of Arrays ..................................... 150 8.4 Debugging Programs with Arrays ............................... 151 8.5 Processing Data in Arrays ................................... 152 8.6 Passing Arrays to Functions .................................. 155 8.7 Plotting Data in Arrays for Graphical Display ......................... 158 8.7.1 Plotting a Curve Using the Member Function data2DCurve() ............ 158 8.7.2 Plotting Points for Scatter Plots and Trend Lines ................... 159 8.7.3 Plotting Multiple Curves in Different Arrays in a Single Plot ............. 162 8.8 Chapter Summary ........................................ 164 8.8.1 Programming Tips ................................... 164 8.8.2 Terminology ...................................... 164 8.9 Exercises ............................................ 164 9 Working with Data Files 167 9.1 Writing Data Into Files ..................................... 167 9.2 Reading Data From Files .................................... 170 9.2.1 Using Function feof() .................................. 172 9.3 Plotting Data
Load more

Recommended publications
  • Object Oriented Programming
    No. 52 March-A pril'1990 $3.95 T H E M TEe H CAL J 0 URN A L COPIA Object Oriented Programming First it was BASIC, then it was structures, now it's objects. C++ afi<;ionados feel, of course, that objects are so powerful, so encompassing that anything could be so defined. I hope they're not placing bets, because if they are, money's no object. C++ 2.0 page 8 An objective view of the newest C++. Training A Neural Network Now that you have a neural network what do you do with it? Part two of a fascinating series. Debugging C page 21 Pointers Using MEM Keep C fro111 (C)rashing your system. An AT Keyboard Interface Use an AT keyboard with your latest project. And More ... Understanding Logic Families EPROM Programming Speeding Up Your AT Keyboard ((CHAOS MADE TO ORDER~ Explore the Magnificent and Infinite World of Fractals with FRAC LS™ AN ELECTRONIC KALEIDOSCOPE OF NATURES GEOMETRYTM With FracTools, you can modify and play with any of the included images, or easily create new ones by marking a region in an existing image or entering the coordinates directly. Filter out areas of the display, change colors in any area, and animate the fractal to create gorgeous and mesmerizing images. Special effects include Strobe, Kaleidoscope, Stained Glass, Horizontal, Vertical and Diagonal Panning, and Mouse Movies. The most spectacular application is the creation of self-running Slide Shows. Include any PCX file from any of the popular "paint" programs. FracTools also includes a Slide Show Programming Language, to bring a higher degree of control to your shows.
    [Show full text]
  • Assignment 6: Subtyping and Bidirectional Typing
    Assignment 6: Subtyping and Bidirectional Typing 15-312: Foundations of Programming Languages Joshua Dunfield ([email protected]) Out: Thursday, October 24, 2002 Due: Thursday, November 7 (11:59:59 pm) 100 points total + (up to) 20 points extra credit 1 Introduction In this assignment, you will implement a bidirectional typechecker for MinML with , , +, 1, 0, , , and subtyping with base types int and float. ! ∗ 8 9 Note: In the .sml files, most changes from Assignment 4 are indicated like this: (* new asst6 code: *) ... (* end asst6 code *) 2 New in this assignment Some things have become obsolete (and have either been removed or left • in a semi-supported state). Exceptions and continuations are no longer “officially” supported. One can now (and sometimes must!) write type annotations e : τ. The • abstract syntax constructor is called Anno. The lexer supports shell-style comments in .mml source files: any line • beginning with # is ignored. There are now two valid syntaxes for functions, the old syntax fun f (x:t1):t2 is e end • and a new syntax fun f(x) is e end. Note the lack of type anno- tations. The definition of the abstract syntax constructor Fun has been changed; its arguments are now just bindings for f and x and the body. It no longer takes two types. 1 The old syntax fun f(x:t1):t2 is e end is now just syntactic sugar, transformed by the parser into fun f(x) is e end : t1 -> t2. There are floating point numbers, written as in SML. There is a new set of • arithmetic operators +., -., *., ˜.
    [Show full text]
  • (901133) Instructor: Eng
    home Al-Albayt University Computer Science Department C++ Programming 1 (901133) Instructor: Eng. Rami Jaradat [email protected] 1 home Subjects 1. Introduction to C++ Programming 2. Control Structures 3. Functions 4. Arrays 5. Pointers 6. Strings 2 home 1 - Introduction to C++ Programming 3 home What is computer? • Computers are programmable devices capable of performing computations and making logical decisions. • Computers can store, retrieve, and process data according to a list of instructions • Hardware is the physical part of the compute: keyboard, screen, mouse, disks, memory, and processing units • Software is a collection of computer programs, procedures and documentation that perform some tasks on a computer system 4 home Computer Logical Units • Input unit – obtains information (data) from input devices • Output unit – outputs information to output device or to control other devices. • Memory unit – Rapid access, low capacity, stores information • Secondary storage unit – cheap, long-term, high-capacity storage, stores inactive programs • Arithmetic and logic unit (ALU) – performs arithmetic calculations and logic decisions • Central processing unit (CPU): – supervises and coordinates the other sections of the computer 5 home Computer language • Machine languages: machine dependent, it consists of strings of numbers giving machine specific instructions: +1300042774 +1400593419 +1200274027 • Assembly languages: English-like abbreviations representing elementary operations, assemblers convert assembly language to machine
    [Show full text]
  • Validated Processor List
    NISTIR 4557 Programming Languages and Database Language SQL VALIDATED PROCESSOR UST Including GOSIP Conformance Testing Registers Judy B. Kailey Editor U.S. DEPARTMENT OF COMMERCE National Institute of Standards and Technology National Computer Systems Laboratory Software Standards Validation Group Gaithersburg, MD 20899 April 1991 (Supersedes January 1991 Issue) U.S. DEPARTMENT OF COMMERCE Robert A. Mosbacher, Secretary NATIONAL INSTITUTE OF STANDARDS AND TECHNOLOGY John W. Lyons, Director NIST > NISTIR 4557 Programming Languages and Database Language SQL VALIDATED PROCESSOR LIST Including GOSIP Conformance Testing Registers Judy B. Kailey Editor U.S. DEPARTMENT OF COMMERCE National Institute of Standards and Technology National Computer Systems Laboratory Software Standards Validation Group Gaithersburg, MD 20899 April 1991 (Supersedes January 1991 Issue) U.S. DEPARTMENT OF COMMERCE Robert A. Mosbacher, Secretary NATIONAL INSTITUTE OF STANDARDS AND TECHNOLOGY John W. Lyons, Director lib t TABLE OF CONTENTS 1. INTRODUCTION 1 1.1 Purpose 1 1.2 Document Organization 1 1.2.1 Language Processors 1 1.2.2 Contributors to the VPL 2 1.2.3 Other FIPS Conformance Testing Products 2 1.2.4 GOSIP Registers 2 1.3 FIPS Programming and Database Language Standards 3 1.4 Validation of Processors 3 1.4.1 Validation Requirements 3 1.4.2 Placement in the List 4 1.4.3 Removal from the List 4 1.4.4 Validation Procedures 4 1.5 Certificate of Validation 4 1.6 Registered Report 4 1.7 Processor Validation Suites 5 2. COBOL PROCESSORS 7 3. FORTRAN PROCESSORS 13 4. Ada PROCESSORS 21 5. Pascal PROCESSORS 35 6. SQL PROCESSORS 37 APPENDIX A CONTRIBUTORS TO THE LIST A-1 APPENDIX B OTHER FIPS CONFORMANCE TESTING B-1 APPENDIX C REGISTER OF GOSIP ABSTRACT TEST SUITES C-1 APPENDIX D REGISTER OF GOSIP MEANS OF TESTING D-1 APPENDIX E REGISTER OF GOSIP CONFORMANCE TESTING LABORATORIES E-1 .
    [Show full text]
  • Explicitly Implicifying Explicit Constructors
    Explicitly Implicifying explicit Constructors Document number: P1163R0 Date: 2018-08-31 Project: Programming Language C++, Library Working Group Reply-to: Nevin “☺” Liber, [email protected] or [email protected] Table of Contents Revision History ................................................................................................................ 3 P11630R0 .................................................................................................................................... 3 Introduction ....................................................................................................................... 4 Motivation and Scope ....................................................................................................... 5 Impact On the Standard ................................................................................................... 6 Policy .................................................................................................................................. 7 Design Decisions ................................................................................................................ 8 Technical Specifications ................................................................................................... 9 [template.bitset]........................................................................................................................ 10 [bitset.cons] ..............................................................................................................................
    [Show full text]
  • The Cool Reference Manual∗
    The Cool Reference Manual∗ Contents 1 Introduction 3 2 Getting Started 3 3 Classes 4 3.1 Features . 4 3.2 Inheritance . 5 4 Types 6 4.1 SELF TYPE ........................................... 6 4.2 Type Checking . 7 5 Attributes 8 5.1 Void................................................ 8 6 Methods 8 7 Expressions 9 7.1 Constants . 9 7.2 Identifiers . 9 7.3 Assignment . 9 7.4 Dispatch . 10 7.5 Conditionals . 10 7.6 Loops . 11 7.7 Blocks . 11 7.8 Let . 11 7.9 Case . 12 7.10 New . 12 7.11 Isvoid . 12 7.12 Arithmetic and Comparison Operations . 13 ∗Copyright c 1995-2000 by Alex Aiken. All rights reserved. 1 8 Basic Classes 13 8.1 Object . 13 8.2 IO ................................................. 13 8.3 Int................................................. 14 8.4 String . 14 8.5 Bool . 14 9 Main Class 14 10 Lexical Structure 14 10.1 Integers, Identifiers, and Special Notation . 15 10.2 Strings . 15 10.3 Comments . 15 10.4 Keywords . 15 10.5 White Space . 15 11 Cool Syntax 17 11.1 Precedence . 17 12 Type Rules 17 12.1 Type Environments . 17 12.2 Type Checking Rules . 18 13 Operational Semantics 22 13.1 Environment and the Store . 22 13.2 Syntax for Cool Objects . 24 13.3 Class definitions . 24 13.4 Operational Rules . 25 14 Acknowledgements 30 2 1 Introduction This manual describes the programming language Cool: the Classroom Object-Oriented Language. Cool is a small language that can be implemented with reasonable effort in a one semester course. Still, Cool retains many of the features of modern programming languages including objects, static typing, and automatic memory management.
    [Show full text]
  • Generic Immutability and Nullity Types for an Imperative Object-Oriented Programming Language with flexible Initialization
    Generic Immutability and Nullity Types for an imperative object-oriented programming language with flexible initialization James Elford June 21, 2012 Abstract We present a type system for parametric object mutability and ref- erence nullity in an imperative object oriented language. We present a simple but powerful system for generic nullity constraints, and build on previous work to provide safe initialization of objects which is not bound to constructors. The system is expressive enough to handle initialization of cyclic immutable data structures, and to enforce their cyclic nature through the type system. We provide the crucial parts of soundness ar- guments (though the full proof is not yet complete). Our arguments are novel, in that they do not require auxiliary runtime constructs (ghost state) in order to express or demonstrate our desired properties. 2 Contents 1 Introduction 4 1.1 In this document . .5 2 Background 6 2.1 Parametric Types . .6 2.1.1 Static Polymorphism through Templates . .7 2.1.2 Static Polymorphism through Generic Types . 12 2.2 Immutability . 18 2.2.1 Immutability in C++ .................... 19 2.2.2 Immutability in Java and C# ............... 21 2.2.3 An extension to Java's immutability model . 21 2.2.4 Parametric Immutability Constraints . 24 2.3 IGJ: Immutability Generic Java .................. 25 2.4 Nullity . 27 2.5 Areas of commonality . 30 3 Goals 32 4 Existing systems in more detail 34 4.1 The initialization problem . 34 4.2 What do we require from initialization? . 35 4.3 Approaches to initialization . 37 4.4 Delay Types and initialization using stack-local regions .
    [Show full text]
  • C DEFINES and C++ TEMPLATES Professor Ken Birman
    Professor Ken Birman C DEFINES AND C++ TEMPLATES CS4414 Lecture 10 CORNELL CS4414 - FALL 2020. 1 COMPILE TIME “COMPUTING” In lecture 9 we learned about const, constexpr and saw that C++ really depends heavily on these Ken’s solution to homework 2 runs about 10% faster with extensive use of these annotations Constexpr underlies the “auto” keyword and can sometimes eliminate entire functions by precomputing their results at compile time. Parallel C++ code would look ugly without normal code structuring. Const and constexpr allow the compiler to see “beyond” that and recognize parallelizable code paths. CORNELL CS4414 - FALL 2020. 2 … BUT HOW FAR CAN WE TAKE THIS IDEA? Today we will look at the concept of programming the compiler using the templating layer of C++ We will see that it is a powerful tool! There are also programmable aspects of Linux, and of the modern hardware we use. By controlling the whole system, we gain speed and predictability while writing elegant, clean code. CORNELL CS4414 - FALL 2020. 3 IDEA MAP FOR TODAY History of generics: #define in C Templates are easy to create, if you stick to basics The big benefit compared to Java is that a template We have seen a number of parameterized is a compile-time construct, whereas in Java a generic types in C++, like std::vector and std::map is a run-time construct. The template language is Turing-complete, but computes These are examples of “templates”. only on types, not data from the program (even when They are like generics in Java constants are provided).
    [Show full text]
  • Class Notes on Type Inference 2018 Edition Chuck Liang Hofstra University Computer Science
    Class Notes on Type Inference 2018 edition Chuck Liang Hofstra University Computer Science Background and Introduction Many modern programming languages that are designed for applications programming im- pose typing disciplines on the construction of programs. In constrast to untyped languages such as Scheme/Perl/Python/JS, etc, and weakly typed languages such as C, a strongly typed language (C#/Java, Ada, F#, etc ...) place constraints on how programs can be written. A type system ensures that programs observe logical structure. The origins of type theory stretches back to the early twentieth century in the work of Bertrand Russell and Alfred N. Whitehead and their \Principia Mathematica." They observed that our language, if not restrained, can lead to unsolvable paradoxes. Specifically, let's say a mathematician defined S to be the set of all sets that do not contain themselves. That is: S = fall A : A 62 Ag Then it is valid to ask the question does S contain itself (S 2 S?). If the answer is yes, then by definition of S, S is one of the 'A's, and thus S 62 S. But if S 62 S, then S is one of those sets that do not contain themselves, and so it must be that S 2 S! This observation is known as Russell's Paradox. In order to avoid this paradox, the language of mathematics (or any language for that matter) must be constrained so that the set S cannot be defined. This is one of many discoveries that resulted from the careful study of language, logic and meaning that formed the foundation of twentieth century analytical philosophy and abstract mathematics, and also that of computer science.
    [Show full text]
  • C Programming Tutorial
    C Programming Tutorial C PROGRAMMING TUTORIAL Simply Easy Learning by tutorialspoint.com tutorialspoint.com i COPYRIGHT & DISCLAIMER NOTICE All the content and graphics on this tutorial are the property of tutorialspoint.com. Any content from tutorialspoint.com or this tutorial may not be redistributed or reproduced in any way, shape, or form without the written permission of tutorialspoint.com. Failure to do so is a violation of copyright laws. This tutorial may contain inaccuracies or errors and tutorialspoint provides no guarantee regarding the accuracy of the site or its contents including this tutorial. If you discover that the tutorialspoint.com site or this tutorial content contains some errors, please contact us at [email protected] ii Table of Contents C Language Overview .............................................................. 1 Facts about C ............................................................................................... 1 Why to use C ? ............................................................................................. 2 C Programs .................................................................................................. 2 C Environment Setup ............................................................... 3 Text Editor ................................................................................................... 3 The C Compiler ............................................................................................ 3 Installation on Unix/Linux ............................................................................
    [Show full text]
  • 2.2 Pointers
    2.2 Pointers 1 Department of CSE Objectives • To understand the need and application of pointers • To learn how to declare a pointer and how it is represented in memory • To learn the relation between arrays and pointers • To study the need for call-by-reference • To distinguish between some special types of pointers 2 Department of CSE Agenda • Basics of Pointers • Declaration and Memory Representation • Operators associated with pointers • address of operator • dereferencing operator • Arrays and Pointers. • Compatibility of pointers • Functions and Pointers • Special types of pointers • void pointer • null pointer • constant pointers • dangling pointers • pointer to pointer 3 Department of CSE Introduction • A pointer is defined as a variable whose value is the address of another variable. • It is mandatory to declare a pointer before using it to store any variable address. 4 Department of CSE Pointer Declaration • General form of a pointer variable declaration:- datatype *ptrname; • Eg:- • int *p; (p is a pointer that can point only integer variables) • float *fp; (fp can point only floating-point variables) • Actual data type of the value of all pointers is a long hexadecimal number that represents a memory address 5 Department of CSE Initialization of Pointer Variable • Uninitialized pointers will have some unknown memory address in them. • Initialize/ Assign a valid memory address to the pointer. Initialization Assignment int a; int a; int *p = &a; int *p; p = &a; • The variable should be defined before pointer. • Initializing pointer to NULL int *p = NULL; 6 Department of CSE Why Pointers? • Manages memory more efficiently. • Leads to more compact and efficient code than that can be obtained in other ways • One way to have a function modify the actual value of a variable passed to it.
    [Show full text]
  • Hyperion Reporting and Analysis – System 9 Installation Guide for Windows
    HYPERION® REPORTING AND ANALYSIS – SYSTEM 9 RELEASE 9.3.1 INSTALLATION GUIDE FOR WINDOWS Reporting and Analysis Installation Guide for Windows, 9.3.1 Copyright © 1989, 2008, Oracle and/or its affiliates. All rights reserved. Authors: Marilyn Ghilardi The Programs (which include both the software and documentation) contain proprietary information; they are provided under a license agreement containing restrictions on use and disclosure and are also protected by copyright, patent, and other intellectual and industrial property laws. Reverse engineering, disassembly, or decompilation of the Programs, except to the extent required to obtain interoperability with other independently created software or as specified by law, is prohibited. The information contained in this document is subject to change without notice. If you find any problems in the documentation, please report them to us in writing. This document is not warranted to be error-free. Except as may be expressly permitted in your license agreement for these Programs, no part of these Programs may be reproduced or transmitted in any form or by any means, electronic or mechanical, for any purpose. If the Programs are delivered to the United States Government or anyone licensing or using the Programs on behalf of the United States Government, the following notice is applicable: U.S. GOVERNMENT RIGHTS Programs, software, databases, and related documentation and technical data delivered to U.S. Government customers are "commercial computer software" or "commercial technical data" pursuant to the applicable Federal Acquisition Regulation and agency-specific supplemental regulations. As such, use, duplication, disclosure, modification, and adaptation of the Programs, including documentation and technical data, shall be subject to the licensing restrictions set forth in the applicable Oracle license agreement, and, to the extent applicable, the additional rights set forth in FAR 52.227-19, Commercial Computer Software--Restricted Rights (June 1987).
    [Show full text]