Refining and Improving Files Using Reports

  Identifying Files with Reminder Annotations

  Generating a Summary View of the Help Components in Functions and Scripts

  Displaying and Updating a Report on the Contents of a Folder

  Displaying Dependencies Among MATLAB Code Files

  Identifying How Much of a File Ran When Profiled

  Running the Code Analyzer Report

  Changing Code Based on Code Analyzer Messages

  Other Ways to Access Code Analyzer Messages

  What Is Profiling?

  Profiling Process and Guidelines

  Using the Profiler

  Profile Summary Report

  Profile Detail Report

  The profile Function

  Overview of Marking Up MATLAB Comments for Publishing

  Creating Document Titles and Introductory Text for Publishing an Existing File

  Specifying Preformatted Text in MATLAB Files for Publishing

  Specifying Bulleted or Numbered Lists in MATLAB Files for Publishing

  Specifying Graphics in MATLAB Files for Publishing

  Using HTML Markup Tags in MATLAB Files for Publishing

  Using LaTeX Markup for Publishing

  Including Inline LaTeX Math Equations in MATLAB Files for Publishing

  Including LaTeX Display Math in MATLAB Files for Publishing

  Forcing a Snapshot of Output in MATLAB Files for Publishing

  Including Bold, Italic, and Monospaced Text in MATLAB Files for Publishing

  Including Trademarks in MATLAB Files for Publishing

  Including Hyperlinks in MATLAB Files for Publishing

  Cleaning Up Text Markup Before Publishing MATLAB Files

  Summary of Markup for Publishing MATLAB Files

  Specifying the Display of Code Output

  Example of Marking Up Code

  Creating a Publish Configuration for a MATLAB File

  Running an Existing Publish Configuration

  Creating Multiple Publish Configurations for a File

  About the publish_configurations.m File

  Finding Publish Configurations

  Removing Publish Configurations

  Reassociating and Renaming Publish Configurations

  Defining Input Cells for a MATLAB Notebook

  Defining Cell Groups for a MATLAB Notebook

  Defining Autoinit Input Cells for a MATLAB Notebook

  Defining Calc Zones for a MATLAB Notebook

  Converting an Input Cell to Text in a MATLAB Notebook

  Evaluating Cell Groups

  Evaluating a Range of Input Cells

  Evaluating a Calc Zone

  Evaluating an Entire MATLAB Notebook

  Using a Loop to Evaluate Input Cells Repeatedly

  Converting Output Cells to Text

  Deleting Output Cells

  Modifying Styles in the MATLAB Notebook Template

  Choosing Loose or Compact Format

  Controlling Numeric Output Format

  Controlling Graphic Output

  Define Autoinit Cell

  Define Calc Zone

  Define Input Cell

  Evaluate Calc Zone

  Evaluate Cell

  Evaluate Loop

  Evaluate MATLAB Notebook

  Group Cells

  Hide Cell Markers

  Notebook Options

  Purge Selected Output Cells

  Toggle Graph Output for Cell

  Undefine Cells

  Ungroup Cells

  Check Files Into Source Control

  Check Files Out of Source Control

  Undoing the Checkout

  Removing Files from the Source Control System

  Showing File History

  Comparing the Working Copy of a File to the Latest Version in Source Control

  Viewing Source Control Properties of a File

  Starting the Source Control System

  Restriction Against @ Character

  Add to Source Control Is the Only Action Available

  More Solutions for Source Control Problems

  Function Alternative

  Setting a View and Checking Out a Folder with ClearCase Software on UNIX Platforms

  Checking In One File Using the Editor, or the Simulink or Stateflow Products

  Function Alternative

  Checking Out a Single File Using the Editor, or the Simulink or Stateflow Products

  Function Alternative

  Undoing the Checkout for One or More Files Using the Current Folder Browser

  Undoing the Checkout for a Single File Using the Editor, or the Simulink or Stateflow Products

  Function Alternative

  Setting Locale on Windows Platforms

  Setting Locale on Linux Platforms

  Setting Locale on Macintosh Platforms

  Characters Incorrectly Displayed on Windows Systems

  datenum Might Not Return Correct Value

  Numbers Display Period for Decimal Point

  MATLAB Displays Messages in English

  File or Folder Names Incorrectly Displayed

  Ways to Import Text Files

  Import Numeric Data from a Text File

  Import Numeric Data and Header Text from a Text File

  Import Mixed Text and Numeric Data from a Text File

  Import Large Text Files

  Import Data from a Nonrectangular Text File

  Import Text Data Files with Low-Level I/O

  Example - Finding Text in an XML File

  Select Spreadsheet Data Interactively

  Import a Worksheet or Range with xlsread

  Import All Worksheets in a File with importdata

  System Requirements for Importing Spreadsheets

  When to Convert Dates from Excel Files

  Importing Network Common Data Form (NetCDF) Files

  Importing Flexible Image Transport System (FITS) Files

  Importing Hierarchical Data Format (HDF5) Files

  Importing Hierarchical Data Format (HDF4) Files

  Reading Image Data and Metadata from TIFF Files

  Reading Audio Files

  Recording and Playing Audio

  Reading Video Files

  Reading Binary Data in a File

  Reading Portions of a File

  Reading Files Created on Other Systems

  Opening Files with Different Character Encodings

  Save Part of a Variable in a MAT-File

  Save Structure Fields as Separate Variables

  MAT-File Versions

  Writing to a Diary File

  Writing to Text Data Files with Low-Level I/O

  Updating an Existing XML File

  Adding a New Worksheet

  File Formats that xlswrite Supports

  Converting Dates

  Formatting Cells in Excel Files

  Exporting to Network Common Data Form (NetCDF) Files

  Exporting to Hierarchical Data Format (HDF5) Files

  Exporting to Hierarchical Data Format (HDF4) Files

  Exporting Video to AVI Files

  Writing Binary Data to a File

  Overwriting or Appending to an Existing File

  Creating a File for Use on a Different System

  Opening Files with Different Character Encodings

  Writing and Reading Complex Numbers

  Benefits of Memory-Mapping

  When to Use Memory-Mapping

  Maximum Size of a Memory Map

  Byte Ordering

  Viewing Properties

  Constructing the Object with Default Property Values

  Changing Property Values

  Selecting the File to Map

  Setting the Start of the Mapped Region

  Identifying the Contents of the Mapped Region

  Mapping of the Example File

  Repeating a Format Scheme

  Setting the Type of Access

  Improving Performance

  Example 1 - Reading a Single Data Type

  Example 2 - Formatting File Data as a Matrix

  Example 3 - Reading Multiple Data Types

  Example 4 - Modifying Map Parameters

  Dimensions of the Data Field

  Writing Matrices to a Mapped File

  Selecting Appropriate Data Types

  Working with Copies of the Mapped Data

  The send Function

  The answer Function

  Running the Demo

  Example - Using the urlwrite Function

  Dimensions of the Matrix

  Classes Used in the Matrix

  Data Structures Used in the Matrix

  Diminishing the Size of a Matrix

  Reshaping a Matrix

  Preallocating Memory

  Shifting the Location of Matrix Elements

  Sorting the Data in Each Column

  Sorting the Data in Each Row

  Sorting Row Vectors

  Constructing a Matrix from a Diagonal Vector

  Returning a Triangular Portion of a Matrix

  Concatenating Matrices Diagonally

  The Empty Matrix

  Scalars

  Vectors

  Sparse Matrix Functions

  Creating Multidimensional Arrays

  Accessing Multidimensional Array Properties

  Indexing Multidimensional Arrays

  Reshaping Multidimensional Arrays

  Permuting Array Dimensions

  Computing with Multidimensional Arrays

  Organizing Data in Multidimensional Arrays

  Multidimensional Cell Arrays

  Multidimensional Structure Arrays

  Adding and Subtracting Matrices

  Vector Products and Transpose

  Multiplying Matrices

  Identity Matrix

  Kronecker Tensor Product

  Vector and Matrix Norms

  Using Multithreaded Computation with Linear Algebra Functions

  The mldivide Algorithm

  General Solution

  Square Systems

  Overdetermined Systems

  Using Multithreaded Computation with Systems of Linear Equations

  Iterative Methods for Solving Systems of Linear Equations

  Pseudoinverses

  Cholesky Factorization

  LU Factorization

  QR Factorization

  Using Multithreaded Computation for Factorization

  Inverse and Fractional Powers

  Element-by-Element Powers

  Exponentials

  Multiple Eigenvalues

  Schur Decomposition

  Choosing a Random Number Generator

  Compatibility Considerations

  Initializing the Generator with an Integer Seed

  Initializing the Generator with a State Vector

  If You Are Unable to Upgrade from Former Syntax

  Functions That Do Not Support Sparse Matrices

  Functions with Sparse Alternatives

  Computational Efficiency

  Importing Sparse Matrices

  Indices and Values

  Indexing in Sparse Matrix Operations

  Visualizing Sparse Matrices

  Permutations and Reordering

  Factoring Sparse Matrices

  Systems of Linear Equations

  Eigenvalues and Singular Values

  Performance Limitations

  Using a Starting Interval

  Using a Starting Point

  Triangulation Face-Vertex Format

  Querying Triangulations Using TriRep

  Creating Delaunay Triangulations

  Triangulation of Point Sets Containing Duplicate Locations

  Nearest-Neighbor Search

  Point Location

  Searching Non-Delaunay Triangulations

  Grid-Based Interpolation

  Interpolation with the interp Family of Functions

  Interpolation with the griddedInterpolant Class

  Interpolating Scattered Data Using griddata and griddatan

  Interpolating Scattered Data Using the TriScatteredInterp Class

  Addressing Problems in Scattered Data Interpolation

  Minimizing Functions of Several Variables

  fminsearch Algorithm

  Maximizing Functions

  Creating an Example File

  Running the Example

  Plotting the Results

  Creating and Using an Output Function

  Structure of the Output Function

  Example of a Nested Output Function

  Fields in optimValues

  States of the Algorithm

  Stop Flag

  Example: Plot Function

  Using Anonymous Functions

  Initial Value Problems

  Types of Solvers

  Solver Syntax

  Integrator Options

  Examples

  Troubleshooting

  Initial Value Problems

  Types of Solvers

  Discontinuities

  Integrator Options

  Examples

  Boundary Value Problems

  BVP Solver

  Integrator Options

  Examples

  Initial Value Problems

  PDE Solver

  Integrator Options

  Examples

  Example: Arc Length

  Example: Double Integration

  Visualizing the DFT

  The FFT in One Dimension

  The FFT in Multiple Dimensions

  Representing Missing Data Values

  Calculating with NaNs

  Removing NaNs from Data

  Interpolating Missing Data

  Filter Function

  Example: Moving Average Filter

  Example: Discrete Filter

  Example: Removing Linear Trends from Data

  Example: Using MATLAB Data Statistics

  How to Brush Data

  Effects of Brushing on Data

  Other Data Brushing Aspects

  Why Use Linked Plots?

  How to Link Plots

  How Linked Plots Behave

  Linking vs. Refreshing Plots

  Using Linked Plot Controls

  Using Data Tips to Explore Graphs

  Example - Visually Exploring Demographic Statistics

  Covariance

  Correlation Coefficients

  Residuals and Goodness of Fit

  Fitting Data with Curve Fitting Toolbox Functions

  Preparing for Basic Fitting

  Opening the Basic Fitting GUI

  Example: Using Basic Fitting GUI

  Linear Model with Nonpolynomial Terms

  Multiple Regression

  Example: Programmatic Fitting

  Time Series Data Sample

  Example: Time Series Objects and Methods

  Time Series Constructor

  Time Series Collection Constructor

  Importing and Exporting Data

  Plotting Time Series

  Selecting Data for Analysis

  Editing Data, Time, Attributes, and Events

  Processing and Manipulating Time Series

  Example: Time Series Tools

  Overview

  Integers

  Floating-Point Numbers

  Complex Numbers

  Infinity and NaN

  Identifying Numeric Classes

  Display Format for Numeric Values

  Function Summary

  Identifying Logical Arrays

  Functions that Return a Logical Result

  Using Logical Arrays in Conditional Statements

  Using Logical Arrays in Indexing

  Cell Arrays of Strings

  Formatting Strings

  String Comparisons

  Searching and Replacing

  Converting from Numeric to String

  Converting from String to Numeric

  Function Summary

  Access Data in a Structure Array

  Concatenate Structures

  Generate Field Names from Variables

  Access Data in Nested Structures

  Access Multiple Elements of a Nonscalar Struct Array

  Ways to Organize Data in Structure Arrays

  Memory Requirements for a Structure Array

  Create a Cell Array

  Access Data in a Cell Array

  Add Cells to a Cell Array

  Delete Data from a Cell Array

  Combine Cell Arrays

  Pass Contents of Cell Arrays to Functions

  Preallocate Memory for a Cell Array

  Cell vs. Struct Arrays

  Multilevel Indexing to Access Parts of Cells

  Creating a Function Handle

  Calling a Function By Means of Its Handle

  Preserving Data from the Workspace

  Applications of Function Handles

  Saving and Loading Function Handles

  Advanced Operations on Function Handles

  Functions That Operate on Function Handles

  Description of the Map Class

  Creating a Map Object

  Examining the Contents of the Map

  Reading and Writing Using a Key Index

  Modifying Keys and Values in the Map

  Mapping to Different Value Types

  Combining Integer and Noninteger Data

  Combining Cell Arrays with Non-Cell Arrays

  Empty Matrices

  Concatenation Examples

  Relational Operators

  Logical Operators

  Operator Precedence

  Date and Time Functions

  Working with Date Strings

  Date String Tables

  Working with Date Vectors

  Working with Serial Date Numbers

  Other Considerations

  Function Summary

  Calling Regular Expression Functions from MATLAB

  Parsing Strings with Regular Expressions

  Other Benefits of Using Regular Expressions

  Metacharacters and Operators

  Character Type Operators

  Character Representation

  Grouping Operators

  Nonmatching Operators

  Positional Operators

  Lookaround Operators

  Quantifiers

  Tokens

  Named Capture

  Conditional Expressions

  Dynamic Regular Expressions

  String Replacement

  Handling Multiple Strings

  Function, Mode Options, Operator, Return Value Summaries

  Generating a Comma-Separated List

  Assigning Output from a Comma-Separated List

  Assigning to a Comma-Separated List

  How to Use the Comma-Separated Lists

  Fast Fourier Transform Example

  At - @

  Colon - :

  Comma - ,

  Curly Braces - { }

  Dot - .

  Dot-Dot - ..

  Dot-Dot-Dot (Ellipsis) - ...

  Dot-Parentheses - .( )

  Exclamation Point - !

  Parentheses - ( )

  Percent - %

  Percent-Brace - %{ %}

  Plus - +

  Semicolon - ;

  Single Quotes - ' '

  Space Character

  Slash and Backslash - / \

  Square Brackets - [ ]

  Tilde - ~

  Creating a Program

  Getting the Bugs Out

  Cleaning Up the Program

  Improving Performance

  Checking It In

  Protecting Your Source Code

  Types of Program Files

  Basic Parts of a Program File

  Creating a Program File

  Providing Help for Your Program

  Cleaning Up When the Function Completes

  Functions

  Types of Functions

  Organizing Your Functions

  Identifying Dependencies

  Determining Which Function Gets Called

  Resolving Difficulties In Calling Functions

  Calling External Functions

  Running External Programs

  Naming Variables

  Guidelines to Using Variables

  Scope of a Variable

  Lifetime of a Variable

  Input Arguments

  Output Arguments

  Passing Arguments in Structures or Cell Arrays

  Passing Optional Arguments

  Working with the Example Function

  The inputParser Class

  Validating Data Passed to a Function

  Calling a Function that Uses the Input Parser

  Substituting Default Values for Arguments Not Passed

  Handling Unmatched Inputs

  Interpreting Arguments Passed as Structures

  Other Features of the Input Parser

  Summary of inputParser Methods and Properties

  Functions

  Built-In Functions

  Overloaded MATLAB Functions

  Internal Utility Functions

  Arrays of Anonymous Functions

  Outputs from Anonymous Functions

  Variables Used in the Expression

  Examples of Anonymous Functions

  Calling Nested Functions

  Variable Scope in Nested Functions

  Using Function Handles with Nested Functions

  Restrictions on Assigning to Variables

  Examples of Nested Functions

  Calling Subfunctions

  Accessing Help for a Subfunction

  Private Folders

  Accessing Help for a Private Function

  Getting Comfortable with Objects

  What Are Objects and Why Use Them?

  Accessing Objects

  Objects In the MATLAB Language

  Other Kinds of Objects Used by MATLAB

  Using General-Purpose Data Structures

  Using Specialized Objects

  Classes Describe How to Create Objects

  Properties Contain Data

  Methods Implement Operations

  Events are Notices Broadcast to Listening Objects

  When to Use Package Names

  Getting Property Values

  Setting Property Values

  Method Syntax

  Class of Objects Returned by Methods

  Editing Objects with the Variable Editor

  Information About Class Members

  Logical Tests for Objects

  Displaying Objects

  Getting Help for MATLAB Objects

  Value Object Copy Behavior

  Handle Object Copy Behavior

  Testing for Handle or Value Class

  Difference Between clear and delete

  Getting an Exception at the Command Line

  Getting an Exception in Your Program Code

  Generating a New Exception

  The MException Class

  Properties of the MException Class

  Methods of the MException Class

  The try-catch Statement

  Suggestions on How to Handle an Exception

  Identifying the Cause

  Warning Statements

  Warning Control Statements

  Output from Control Statements

  Saving and Restoring State

  Backtrace and Verbose Modes

  Example: Displaying a Message

  Naming the Object

  Setting the Value of Timer Object Properties

  Starting a Timer at a Specified Time

  Stopping Timer Objects

  Blocking the MATLAB Command Line

  Creating Callback Functions

  Specifying the Value of Callback Function Properties

  Executing a Timer Callback Function Multiple Times

  Handling Callback Function Queuing Conflicts

  Testing the Validity of a Timer Object

  Finding Invisible Timer Objects

  The Profiler Utility

  Stopwatch Timer Functions

  Limiting Size and Complexity

  Assigning to Variables

  Using Appropriate Logical Operators

  Overloading Built-In Functions

  Functions Are Generally Faster Than Scripts

  Load and Save Are Faster Than File I/O Functions

  Vectorizing Loops

  Avoid Large Background Processes

  Data Structures and Memory

  Using Appropriate Data Storage

  How to Avoid Fragmenting Memory

  Reclaiming Used Memory

  Setting the Process Limit

  Disabling Java VM on Startup

  Increasing System Swap Space

  Using the 3GB Switch on Windows Systems

  Freeing Up System Resources on Windows Systems

  Help Summary for Your Program Files (Contents.m)

  Help for Classes You Create

  Learning to Add Help from Examples

  Summary of Creating and Installing HTML Help Files

  Organizing Your Documentation

  Creating Function Reference Pages

  Creating Function and Block Category Listings

  Making Your HTML Help Files Searchable

  Summary of Workflow for Providing HTML Help Files

  Providing Demos to Others

  Entities Missing or Out of Order in info.xml

  Unrelated info.xml File

  Invalid Constructs in info.xml File

  Outdated info.xml File for a MathWorks Product

  Command and Function Syntaxes

  Command Line Continuation

  Completing Commands Using the Tab Key

  Recalling Commands

  Clearing Commands

  Suppressing Output to the Screen

  Help on Functions from the Help Browser

  Help on Functions from the Command Window

  Topical Help

  Paged Output

  Writing Your Own Help

  Help for Subfunctions and Private Functions

  Help for Methods and Overloaded Functions

  Using the Find and Replace Utility

  Commenting Out a Block of Code

  Creating Functions from Command History

  Editing Functions in EMACS

  Using Lowercase for Function Names

  Getting a Function's Name and Path

  What Files Does a Function Use?

  Dependent Functions, Built-Ins, Classes

  Variable Numbers of Arguments

  String or Numeric Arguments

  Passing Arguments in a Structure

  Passing Arguments in a Cell Array

  Using Pseudo-Code

  Selecting the Right Data Structures

  General Coding Practices

  Naming a Function Uniquely

  The Importance of Comments

  Coding in Steps

  Making Modifications in Steps

  Functions with One Calling Function

  Testing the Final Program

  More Debug Functions

  The MATLAB Graphical Debugger

  A Quick Way to Examine Variables

  Setting Breakpoints from the Command Line

  Finding Line Numbers to Set Breakpoints

  Stopping Execution on an Error or Warning

  Locating an Error from the Error Message

  Using Warnings to Help Debug

  Making Code Execution Visible

  Debugging Scripts

  Making Sure Variable Names Are Valid

  Do Not Use Function Names for Variables

  Checking for Reserved Keywords

  Avoid Using i and j for Variables

  Avoid Overwriting Variables in Scripts

  Persistent Variables

  Protecting Persistent Variables

  Global Variables

  Comparing Methods of Concatenation

  Store Arrays of Strings in a Cell Array

  Converting Between Strings and Cell Arrays

  Search and Replace Using Regular Expressions

  Assigning to a Series of Variables

  Short-Circuit Logical Operators

  Changing the Counter Variable within a for Loop

  File Precedence

  Adding a Folder to the Search Path

  Handles to Functions Not on the Path

  Making Toolbox File Changes Visible to MATLAB

  Making Nontoolbox File Changes Visible to MATLAB

  Change Notification on Windows

  Using switch Versus if

  MATLAB case Evaluates Strings

  Multiple Conditions in a case Statement

  Implicit Break in switch-case

  Variable Scope in a switch

  Catching Errors with try-catch

  Nested try-catch Blocks

  Forcing an Early Return from a Function

  Loading Data into the Workspace

  Viewing Variables in a MAT-File

  Appending to a MAT-File

  Save and Load on Startup or Quit

  Saving to an ASCII File

  Naming Other Files

  Passing Filenames as Arguments

  Passing Filenames to ASCII Files

  Determining Filenames at Run-Time

  Returning the Size of a File

  Loading Mixed Format Data

  Reading Files with Different Formats

  Interactive Input into Your Program

  Searching Text with grep

  Constructing Paths and Filenames

  Finding the MATLAB Root Folder

  Temporary Directories and Filenames

  Archived CSSM

  MATLAB Technical Support

  Tech Notes

  MATLAB Central

  MATLAB Newsletters (Digest, News & Notes)

  MATLAB Documentation

  MATLAB Index of Examples

  Classes

  Some Basic Relationships

  Examples to Get Started

  Learning Object-Oriented Programming

  Implementing the BankAccount Class

  Implementing the AccountManager Class

  Using the BankAccount Class

  Performing a Task with an Object

  Using Objects in Functions

  Objects As Data Structures

  Structure of the Data

  Defining the TensileData Class

  Creating an Instance and Assigning Data

  Restricting Properties to Specific Values

  Simplifying the Interface with a Constructor

  Using a Dependent Property

  Displaying TensileData Objects

  A Method to Plot Stress vs. Strain

  Important Concepts Demonstrated

  dlnode Class Design

  Creating Doubly Linked Lists

  Why a Handle Class for Doubly Linked Lists?

  Defining the dlnode Class

  Specializing the dlnode Class

  Class Definition Block

  Using the topo Class

  Behavior of the Handle Class

  Grouping Classes with Package Folders

  More Information on Class Folders

  More In Depth Information

  Assigning Class Attributes

  Specifying Superclasses

  How to Initialize Property Values

  Defining Default Values

  Assigning Property Values from Within the Constructor

  Initializing Properties to Unique Values

  Property Attributes

  Property Access Methods

  Referencing Object Properties Using Variables

  Method Calling Syntax

  Methods In Separate Files

  Defining Private Methods

  More Detailed Information On Methods

  Defining Class-Related Functions

  Overloading Functions and Operators

  Listening for Events

  Attribute Descriptions

  Specifying Attribute Values

  Simpler Syntax for true/false Attributes

  Calling Superclass Methods

  Warnings Caused by Variable/Property Name Conflicts

  Exception to Variable/Property Name Rule

  Functions to Test Objects

  Using Switch/Case Statements with Objects

  Changes to Class Constructors

  New Features Introduced with Version 7.6

  Examples of Old and New

  Modifying Objects

  Common Object-Oriented Techniques

  Specifying Attributes

  Where Can You Use Expressions

  How MATLAB Evaluates Expressions

  @-Folders

  Path Folders

  Access to Functions Defined in Private Folders

  Class Precedence and MATLAB Path

  Referencing Package Members Within Packages

  Referencing Package Members from Outside the Package

  Packages and the MATLAB Path

  Syntax for Importing Classes

  Why Select Handle or Value

  Behavior of MATLAB Built-In Classes

  Behavior of User-Defined Classes

  When to Use Handle Classes

  When to Use Value Classes

  Handle Class Methods

  Relational Methods

  Testing Handle Validity

  When MATLAB Destroys Objects

  Handle Class Delete Methods

  Finding Handle Object Properties

  Subclass hgsetget

  Get Method Syntax

  Set Method Syntax

  Subclassing hgsetget

  Types of Properties

  Accessing Property Values

  Inheritance of Properties

  Specifying Property Attributes

  Property Set Methods

  Property Get Methods

  Set and Get Methods for Dependent Properties

  Set and Get Method Execution and Property Events

  Access Methods and Subscripted Reference and Assignment

  Performing Additional Steps with Property Access Methods

  Defining Dynamic Properties

  Responding to Dynamic-Property Events

  Defining Property Access Methods for Dynamic Properties

  Dynamic Properties and ConstructOnLoad

  Determining Which Method Is Invoked

  Specifying Precedence

  Controlling Access to Methods

  Invoking Superclass Methods in Subclass Methods

  Invoking Built-In Methods

  Related Information

  Examples of Class Constructors

  Initializing the Object Within a Constructor

  Constructing Subclasses

  Errors During Class Construction

  Basic Structure of Constructor Methods

  Calling Static Methods

  Rules for Naming to Avoid Conflicts

  General Syntax for Callbacks

  Object Scope and Anonymous Functions

  Example - Class Method as a Slider Callback

  Initializing Arrays of Value Objects

  Initial Value of Object Properties

  Creating Empty Arrays

  Initializing Arrays of Handle Objects

  Referencing Property Values in Object Arrays

  Object Arrays with Dynamic Properties

  MATLAB Concatenation Rules

  Concatenating Objects

  Converting to the Dominant Class

  Implementing Converter Methods

  Some Basic Examples

  Simple Event Listener Example

  Responding to a Button Click

  Default Event Data

  Events Only in Handle Classes

  Property-Set and Query Events

  Listeners

  Triggering Events

  Listening to Events

  Defining Event-Specific Data

  Ways to Create Listeners

  Defining Listener Callback Functions

  Callback Execution

  Example Property Event and Listener Classes

  Aborting Set When Value Does Not Change

  Access Fully Commented Example Code

  Techniques Demonstrated in This Example

  Summary of fcneval Class

  Summary of fcnview Class

  Methods Inherited from Handle Class

  Using the fcneval and fcnview Classes

  Implementing the UpdateGraph Event and Listener

  Implementing the PostSet Property Event and Listener

  Enabling and Disabling the Listeners

  Developing the Abstraction

  Designing Class Hierarchies

  Super and Subclass Behavior

  Implementation and Interface Inheritance

  Referencing Superclasses from Subclasses

  Constructor Arguments and Object Initialization

  Call Only Direct Superclass from Constructor

  Sequence of Constructor Calls in a Class Hierarchy

  Using a Subclass to Create an Alias for an Existing Class

  Modifying Superclass Properties

  Private Local Property Takes Precedence in Method

  Handle Compatibility Rules

  Defining Handle-Compatible Classes

  Subclassing Handle-Compatible Classes

  Methods for Handle Compatible Classes

  Handle Compatible Classes and Heterogeneous Arrays

  Why Subclass Built-In Classes

  Behavior of Built-In Functions with Subclass Objects

  Example - A Class to Manage uint8 Data

  Example - Adding Properties to a Built-In Subclass

  Understanding size and numel

  Example - A Class to Represent Hardware

  Interfaces and Abstract Classes

  Example - Interface for Classes Implementing Graphs

  When to Modify Object Saving and Loading

  Processing Objects During Load

  Save and Load Applications

  Code for This Example

  Example Overview

  Avoiding Property Initialization Order Dependency

  When to Use Transient Properties

  Calling Constructor When Loading

  Using Enumeration Classes

  Defining Methods in Enumeration Classes

  Defining Properties in Enumeration Classes

  Array Expansion Operations

  Constructor Calling Sequence

  Restrictions Applied to Enumeration Classes

  Techniques for Defining Enumerations

  Why Derive Enumeration Class from Built-In Classes

  Aliasing Enumeration Names

  Superclass Constructor Returns Underlying Value

  Default Converter

  Selecting Handle- or Value-Based Enumerations

  Value-Based Enumeration Classes

  Handle-Based Enumeration Classes

  Example - Using Enumerations to Represent a State

  Store Data in Properties

  Built-In and Value-Based Enumeration Classes

  Simple and Handle-Based Enumeration Classes

  What Causes Loading as a Struct Instead of an Object

  Setting Constant Property Default

  Metaclass EnumeratedValues Property

  Find Class Members with Attribute Settings

  Example - Find Properties with Specific Attributes

  Which Methods Control Which Behaviors

  Overloading and Overriding Functions and Methods

  When to Overload MATLAB Functions

  Caution When Overloading MATLAB Functions

  Default Indexed Reference and Assignment

  What You Can Modify

  subsref and subsasgn Within Class Methods - Built-In Called

  Understanding Indexed Reference

  Avoid Overriding Access Attributes

  Understanding Indexed Assignment

  A Class with Modified Indexing

  Defining end Indexing for an Object

  Using Objects as Indices

  MATLAB Operators and Associated Functions

  Displaying the Class Files

  Summary of the DocPolynom Class

  The DocPolynom Constructor Method

  Removing Irrelevant Coefficients

  Converting DocPolynom Objects to Other Types

  The DocPolynom disp Method

  The DocPolynom subsref Method

  Defining Arithmetic Operators for DocPolynom

  Overloading MATLAB Functions for the DocPolynom Class

  Designing a Class for Financial Assets

  Displaying the Class Files

  Summary of the DocAsset Class

  The DocAsset Constructor Method

  The DocAsset Display Method

  Designing a Class for Stock Assets

  Displaying the Class Files

  Summary of the DocStock Class

  Designing a Class for Bond Assets

  Displaying the Class Files

  Summary of the DocBond Class

  Designing a Class for Savings Assets

  Displaying the Class Files

  Summary of the DocSavings Class

  Designing the DocPortfolio Class

  Displaying the Class Files

  Summary of the DocPortfolio Class

  The DocPortfolio Constructor Method

  The DocPortfolio disp Method

  The DocPortfolio pie3 Method

  Visualizing a Portfolio

  Identifying Workspace Data to Plot

  Adding a Subplot

  Plotting Expressions

  Varying the Data Source

  Data Sources for Multiobject Graphs

  Data Arguments

  Limitations

  Interactive Plot Editing

  Using Functions to Edit Graphs

  Starting Plot Edit Mode

  Exiting Plot Edit Mode

  Selecting Objects in a Graph

  Cutting, Copying, and Pasting Plot Objects

  Moving and Resizing Objects

  Setting Object Properties

  Undo/Redo - Eliminating Mistakes

  Saving to a Different Format - Exporting Figures

  Printing Figures

  Generating a MATLAB File to Recreate a Graph

  Types of Tools

  Customizing Data Exploration Tools

  Enabling Data Cursor Mode

  Display Style - Datatip or Cursor Window

  Selection Style - Select Data Points or Interpolate Points on Graph

  Exporting Data Value to Workspace Variable

  Zooming in 2-D Views

  Selecting Predefined Views

  Rotation Style for Complex Graphs

  Undo/Redo - Eliminating Mistakes

  Enclosing Regions of a Graph in a Rectangle or an Ellipse

  Textbox Annotations

  Annotation Lines and Arrows

  Adding a Colorbar to a Graph

  Adding a Legend to a Graph

  Pinning - Attaching to a Point in the Graph

  Example - Vertical Distribute, Horizontal Align

  Align/Distribute Menu Options

  Snap to Grid - Aligning Objects on a Grid

  Using the Title Option on the Insert Menu

  Using the Property Editor to Add a Title

  Using the title Function

  Using the Label Options on the Insert Menu

  Using the Property Editor to Add Axis Labels

  Using Axis-Label Commands

  Creating Text Annotations with the text or gtext Function

  Text Alignment

  Example - Aligning Text

  Editing Text Objects

  Mathematical Symbols, Greek Letters, and TeX Characters

  Using Character and Numeric Variables in Text

  Example - Multiline Text

  Example - Using LaTeX to Format Math Equations

  Drawing Text in a Box

  Editing Arrows and Line Annotations

  Displaying Multiple Plots per Figure

  Specifying the Target Axes

  Default Color Scheme

  Programmatic Plotting

  Creating Line Plots

  Specifying Line Style

  Colors, Line Styles, and Markers

  Specifying the Color and Size of Lines

  Adding Plots to an Existing Graph

  Plotting Only the Data Points

  Plotting Markers and Lines

  Line Styles for Black and White Output

  Setting Default Line Styles

  Combining Linear and Logarithmic Axes

  Axis Limits and Ticks

  Example - Specifying Ticks and Tick Labels

  Setting Aspect Ratio

  Coloring 2-D Bars According to Height

  Coloring 3-D Bars According to Height

  Stacked Bar Graphs to Show Contributing Amounts

  Specifying X-Axis Data

  Overlaying Bar Graphs

  Overlaying Other Plots on Bar Graphs

  Area Graphs

  Comparing Data Sets with Area Graphs

  Labeling the Pie Chart

  Removing a Piece from a Pie Chart

  Histograms in Cartesian Coordinates

  Histograms in Polar Coordinates

  Specifying Number of Bins

  Using Data Cursors with Histograms

  Two-Dimensional Stem Plots

  Combining Stem Plots with Line Plots

  Three-Dimensional Stem Plots

  Stairstep Plots

  Compass Plots

  Feather Plots

  Two-Dimensional Quiver Plots

  Three-Dimensional Quiver Plots

  Creating Simple Contour Plots

  Labeling Contours

  Filled Contours

  Specifying Contour Levels

  Index Contours

  The Contouring Algorithm

  Changing the Offset of a Contour

  Displaying Contours in Polar Coordinates

  Preparing Data for Contouring

  Movies

  Example - Visualizing an FFT as a Movie

  Updating Plot Object Axis and Color Data

  Supported Image Formats

  Functions for Reading, Writing, and Displaying Images

  Intensity Images

  RGB (Truecolor) Images

  8-Bit and 16-Bit Intensity Images

  8-Bit and 16-Bit RGB Images

  Mathematical Operations Support for uint8 and uint16

  Other 8-Bit and 16-Bit Array Support

  Converting an 8-Bit RGB Image to Grayscale

  Summary of Image Types and Numeric Classes

  Reading a Graphics Image

  Writing a Graphics Image

  Subsetting a Graphics Image (Cropping)

  Obtaining Information About Graphics Files

  Controlling Aspect Ratio and Display Size

  Image CDataMapping

  XData and YData

  Adding Text to Images

  Additional Techniques for Fast Image Updating

  Graphical User Interfaces

  Command Line Interface

  Specifying Parameters and Options

  Default Settings and How to Change Them

  Printing a Figure

  Printing to a File

  Exporting to a File

  Exporting to the Windows or Macintosh Clipboard

  Printing with a Specific Paper Size

  Printing a Centered Figure

  Exporting in a Specific Graphics Format

  Exporting in EPS Format with a TIFF Preview

  Exporting a Figure to the Clipboard

  Selecting the Figure

  Selecting the Printer

  Setting the Figure Size and Position

  Setting the Paper Size or Type

  Setting the Paper Orientation

  Selecting a Renderer

  Setting the Resolution

  Setting the Axes Ticks and Limits

  Setting the Background Color

  Setting Line and Text Characteristics

  Setting the Line and Text Color

  Specifying a Colorspace for Printing and Exporting

  Excluding User Interface Controls form Printed Output

  Producing Uncropped Figures

  Frequently Used Graphics Formats

  Factors to Consider in Choosing a Format

  Properties Affected by Choice of Format

  Impact of Rendering Method on the Output

  Description of Selected Graphics Formats

  How to Specify a Format for Exporting

  Factors to Consider in Choosing a Driver

  Driver-Specific Information

  How to Specify the Printer Driver to Use

  Common Problems

  Printing Problems

  Exporting Problems

  General Problems

  Information on Specific Graphics Objects

  Figures Used for Graphing Data

  Figures Used for GUIs

  Root Object - The Figure Parent

  More Information on Figures

  Core Graphics Objects

  Example - Creating Core Graphics Objects

  Parenting

  High-Level Versus Low-Level Functions

  Simplified Calling Syntax

  Creating a Plot Object

  Identifying Plot Objects Programmatically

  Plot Objects and Backward Compatibility

  Data Source Example

  Changing the Size of Data Variables

  Annotation Object Properties

  Annotation Layer

  Example - Enclosing Subplots with an Annotation Rectangle

  Creating a Group

  Transforming Objects

  Storing Object Information

  Changing Values

  Order Dependence of Setting Property Values

  Default Values

  Properties Common to All Objects

  Setting Property Values

  Querying Property Values

  How MATLAB Searches for Default Values

  Defining Default Values

  Examples - Setting Default Line Styles

  Special Object Handles

  The Current Figure, Axes, and Object

  Searching for Objects by Property Values - findobj

  Copying Objects

  Deleting Objects

  Specifying the Target for Graphics Output

  Preparing Figures and Axes for Graphics

  Targeting Graphics Output with newplot

  Example - Using newplot

  Testing for Hold State

  Protecting Figures and Axes

  Quitting the MATLAB Environment

  Errors in the Close Request Function

  Overriding the Close Request Function

  Redefining the CloseRequestFcn

  Save Information First

  Figure Resize Functions

  Example - Using Figure Panels

  Example - Translating Grouped Objects

  Properties for Controlling Legend Content

  Updating a Legend

  Example - Excluding a Particular Object From a Legend

  Example - One Legend Entry for a Group of Objects

  Example - Showing Children of Group Objects in Legend

  Example - Grouping Objects to Reduce the Legend Entries

  Graphics Object Callbacks

  User Interface Object Callbacks

  Figure Callbacks

  Function Handle Syntax

  Why Use Function Handle Callbacks

  Example - Using Function Handles in GUIs

  General Performance Guidelines

  Disabling Automatic Modes

  Changing Graph Data Rapidly

  Specify Axes with Plotting Function for Better Performance

  Performance of Bit-Mapped Images

  Performance of Patch Objects

  Performance of Surface Objects

  Figure Properties That Affect Docking

  Creating a Nondockable Figure

  The Position Vector

  Example - Specifying Figure Position

  Specifying the Figure Colormap

  Selecting a Renderer

  Defining Custom Pointers

  Creating Axes with Specific Characteristics

  Axis Labels

  The Position Vector

  Position Units

  Using OuterPosition as the ActivePositionProperty

  ActivePositionProperty = OuterPosition

  ActivePositionProperty = Position

  Axes Resizing in Subplots

  Placing Text Outside the Axes

  Multiple Axes for Different Scaling

  Setting Axis Limits

  Setting Tick Mark Locations

  Changing Axis Direction

  Example - Double Axis Graphs

  Specifying Axes Colors

  Simulating Multiple Colormaps in a Figure

  Complete Example Code

  Calculating Color Limits

  Defining Your Own ColorOrder

  Line Styles Used for Plotting - LineStyleOrder

  Coloring Techniques

  Types of Color Data

  Colormaps

  Indexed Color Surfaces - Direct and Scaled Color Mapping

  Example - Mapping Surface Curvature to Color

  Altering Colormaps

  Truecolor Surfaces

  Texture Mapping

  Positioning the Viewpoint

  Setting the Aspect Ratio

  Default Views

  Camera Motion Controls

  Orbit Camera

  Orbit Scene Light

  Pan/Tilt Camera

  Move Camera Horizontally/Vertically

  Move Camera Forward and Backward

  Zoom Camera

  Camera Roll

  Implementation

  Graphing the Volume Data

  Setting Up the View

  Specifying the Light Source

  Selecting a Renderer

  Defining the Camera Path as a Stream Line

  Implementing the Fly-Through

  Default Viewpoint Selection

  Moving In and Out on the Scene

  Making the Scene Larger or Smaller

  Revolving Around the Scene

  Rotation Without Resizing of Graphics Objects

  Rotation About the Viewing Axis

  Projection Types and Camera Location

  Specifying Axis Scaling

  Specifying Aspect Ratio

  Example - axis Command Options

  Additional Commands for Setting Aspect Ratio

  Default Aspect Ratio Selection

  Overriding Stretch-to-Fill

  Effects of Setting Aspect Ratio Properties

  Example - Displaying Cross-Sections of Surfaces

  Example - Displaying Real Objects

  Light Objects

  Properties That Affect Lighting

  Examples of Lighting Control

  Ambient Light

  Specular Exponent

  Specular Color Reflectance

  Back Face Lighting

  Positioning Lights in Data Space

  Specifying Transparency

  Example - A Transparent Isosurface

  Size of the Alpha Data Array

  Mapping Alpha Data to the Alphamap

  Example - Mapping Data to Color or Transparency

  Example - Modifying the Alphamap

  Behavior of the patch Function

  Creating a Single Polygon

  Handling Mixed Data Specification

  Patch Edge Coloring

  Coloring Edges with Shared Vertices

  Indexed Color Data

  Truecolor Patches

  Interpolating in Indexed Color Versus Truecolor

  Selecting Visualization Techniques

  Steps to Create a Volume Visualization

  Volume Visualization Functions

  Example - Ways to Display MRI Data

  Modify the Color Mapping

  Other Isocap Applications

  Defining Isocaps

  Example - Adding Isocaps to an Isosurface

  Using Scalar Techniques with Vector Data

  Specifying Starting Points for Stream Plots

  Accessing Subregions of Volume Data

  1. Determine the Range of the Coordinates

  2. Add Slice Planes for Visual Context

  3. Add Contour Lines to the Slice Planes

  4. Define the Starting Points for the Stream Lines

  5. Define the View

  1. Select a Subset of Data to Plot

  2. Calculate Curl Angular Velocity and Wind Speed

  3. Create the Stream Ribbons

  4. Define the View and Add Lighting

  1. Load Data and Calculate Required Values

  2. Draw the Slice Planes

  3. Add Contour Lines to Slice Planes

  4. Create the Stream Tubes

  5. Define the View

  1. Specify Starting Points of the Data Range to Plot

  2. Create Stream Lines to Indicate Particle Paths

  3. Define the View

  4. Calculate the Stream Particle Vertices

  1. Create an Isosurface

  2. Add Isocaps to the Isosurface

  3. Create the First Set of Cones

  4. Create Second Set of Cones

  5. Define the View

  6. Add Lighting

  What Is GUIDE?

  Opening GUIDE

  Getting Help in GUIDE

  Laying Out a GUIDE GUI

  Programming a GUIDE GUI

• About the Simple GUIDE GUI Example

• Lay Out the Simple GUI in GUIDE

  Save the GUI Layout

• Program the Simple GUIDE GUI

• Use the Completed Simple GUIDE GUI

  Create the Simple Programmatic GUI Code File

• Lay Out the Simple Programmatic GUI

• Code the Simple Programmatic GUI

• Use the Completed Simple Programmatic GUI

  GUIDE Tools Summary

• GUI Options

  Start GUIDE

• Select a GUI Template

• Set the GUI Size

• Add Components to the GUI

• Align Components

  Set Tab Order

• Create Menus in a GUIDE GUI

• Create Toolbars

  View the Object Hierarchy

• Designing for Cross-Platform Compatibility

• Save a GUIDE GUI

• Run a GUIDE GUI

• Files Generated by GUIDE

• Default Callback Properties in GUIDE

• Customizing Callbacks in GUIDE

• Initialize a GUIDE GUI

• Add Code for Components in Callbacks

• Making Multiple GUIs Work Together

• GUI for Animating a 3-D View (GUIDE)

• GUI to Interactively Explore Data in a Table (GUIDE)

• List Box Directory Reader (GUIDE)

• Access Workspace Variables from a List Box (GUIDE)

• A GUI to Set Simulink Model Parameters (GUIDE)

• An Address Book Reader (GUIDE)

• Use a Modal Dialog Box to Confirm an Operation (GUIDE)

• Time Data Updates from a GUI (GUIDE)

• Create and Run a Programmatic GUI

  Create Figures for Programmatic GUIs

• Add Components to a Programmatic GUI

• Compose and Code GUIs with Interactive Tools

• Set Tab Order in a Programmatic GUI

• Create Menus for a Programmatic GUI

• Create Toolbars for Programmatic GUIs

• Design Programmatic GUIs for Cross-Platform Compatibility

• Initialize a Programmatic GUI

• Write Code for Callbacks

• Examples: Program GUI Components

• Share Data Among a GUI's Callbacks

• GUI with Axes, Menu, and Toolbar

• GUI that Displays and Graphs Tabular Data

• A GUI That Manages List Data

• Color Palette

• Icon Editor

  List of Examples

  Creating a MAT-File in C

  Creating a MAT-File in C++

  Reading a MAT-File in C/C++

  Creating a MAT-File in Fortran

  Reading a MAT-File in Fortran

  Building on Windows Operating Systems

  Deploying MAT-File Applications

  Selecting a Compiler

  Loading the Library

  Unloading the Library

  Viewing Library Functions

  Invoking Library Functions

  Limitations to Shared Library Support

  Troubleshooting Shared Library Applications

  Passing Arguments

  Examples of Passing Data to Shared Libraries

  Passing Pointers

  Passing a NULL Pointer

  Manually Converting Data Passed to Functions

  Constructing a libpointer Object

  Reading a libpointer Object

  Creating a Pointer to a Primitive Type

  Creating a Pointer to a Structure

  Passing a Pointer to the First Element of an Array

  Putting a String into a Void Pointer

  Passing an Array of Strings

  Memory Allocation for an External Library

  Multilevel Pointers

  Working with Structures Examples

  Finding Structure Field Names

  Example of Passing a MATLAB Structure

  Passing a libstruct Object

  Using the Structure as an Object

  Definition of MEX

  MEX and MX Matrix Libraries

  Introduction to Source MEX-Files

  Overview of Creating a Binary MEX-File

  Configuring Your Environment

  Workflow of a MEX-File

  Using Binary MEX-Files

  Binary MEX-File Placement

  Using Help Files with MEX-Files

  Workspace for MEX-File Functions

  Data Storage

  MATLAB Types

  Sparse Matrices

  Using Data Types

  Selecting a Compiler on Windows Platforms

  Selecting a Compiler on UNIX Platforms

  Linking Multiple Files

  Overview of Building the timestwo MEX-File

  Configuration Issues

  Understanding MEX-File Problems

  Compiler and Platform-Specific Issues

  Memory Management Issues

  MEX Script Switches

  Custom Building on UNIX Systems

  Custom Building on Windows Systems

  Creating a MEX-File Using LAPACK and BLAS Functions

  Preserving Input Values from Modification

  Passing Arguments to Fortran Functions from C/C++ Programs

  Passing Arguments to Fortran Functions from Fortran Programs

  Handling Complex Numbers in LAPACK and BLAS Functions

  Modifying the Function Name on UNIX Systems

  MEX Uses 32-Bit API by Default

  What If I Do Not Upgrade?

  How to Upgrade MEX-Files to Use the 64-Bit API

  Gateway Routine

  Computational Routine

  Preprocessor Macros

  Data Flow in MEX-Files

  Creating C++ MEX-Files

  Passing a Scalar

  Passing Strings

  Passing Two or More Inputs or Outputs

  Passing Structures and Cell Arrays

  Filling an mxArray

  Prompting User for Input

  Handling Complex Data

  Handling 8-, 16-, and 32-Bit Data

  Manipulating Multidimensional Numerical Arrays

  Handling Sparse Arrays

  Calling Functions from C/C++ MEX-Files

  Using C++ Features in MEX-Files

  File Handling with C++

  Debugging on the Microsoft Windows Platforms

  Debugging on Linux Platforms

  Building the Binary MEX-File

  Example

  Caution Using Negative Values

  Building Cross-Platform Applications

  Persistent Arrays

  Hybrid Arrays

  Specifying Constant Literal Values

  Opening a File

  Printing Formatted Messages

  Replacing fseek and ftell with 64-Bit Functions

  Determining the Size of an Open File

  Determining the Size of a Closed File

  Gateway Routine

  Computational Routine

  Preprocessor Macros

  Using the Fortran %val Construct

  Data Flow in MEX-Files

  Passing a Scalar

  Passing Strings

  Passing Arrays of Strings

  Passing Matrices

  Passing Integers

  Passing Two or More Inputs or Outputs

  Handling Complex Data

  Dynamically Allocating Memory

  Handling Sparse Matrices

  Calling Functions from Fortran MEX-Files

  Debugging on Microsoft Windows Platforms

  Debugging on Linux Platforms

  Building the Binary MEX-File

  Caution Using Negative Values

  Building Cross-Platform Applications

  What You Need to Build Engine Applications

  The Engine Library

  GUI-Intensive Applications

  Calling MATLAB Software from a C Application

  Calling MATLAB Software from a C++ Application

  Calling MATLAB Software from a Fortran Application

  Attaching to an Existing MATLAB Session

  Building and Running Engine Applications on Windows Operating Systems

  Windows Engine Example engwindemo

  Building and Running Engine Applications on UNIX Operating Systems

  UNIX Engine Example engdemo

  Files Required by Engine Applications

  Debugging MATLAB Functions Used in Engine Applications

  Benefits of the MATLAB Java Interface

  Who Should Use the MATLAB Java Interface

  To Learn More About Java Programming Language

  Platform Support for JVM Software

  Using a Different Versi