--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/doc/interpreter/data.txi	Tue Oct 19 10:08:42 1999 +0000
@@ -0,0 +1,174 @@
+@c Copyright (C) 1996, 1997 John W. Eaton
+@c This is part of the Octave manual.
+@c For copying conditions, see the file gpl.texi.
+
+@node Data Types, Numeric Data Types, Getting Started, Top
+@chapter Data Types
+@cindex data types
+
+All versions of Octave include a number of built-in data types,
+including real and complex scalars and matrices, character strings, and
+a data structure type.
+
+It is also possible to define new specialized data types by writing a
+small amount of C++ code.  On some systems, new data types can be loaded
+dynamically while Octave is running, so it is not necessary to recompile
+all of Octave just to add a new type.  @xref{Dynamically Linked
+Functions} for more information about Octave's dynamic linking
+capabilities.  @ref{User-defined Data Types} describes what you must do
+to define a new data type for Octave.
+
+@menu
+* Built-in Data Types::         
+* User-defined Data Types::     
+* Object Sizes::                
+@end menu
+
+@node Built-in Data Types, User-defined Data Types, Data Types, Data Types
+@section Built-in Data Types
+@cindex data types, built-in
+@cindex built-in data types
+
+The standard built-in data types are real and complex scalars and
+matrices, ranges, character strings, and a data structure type.
+Additional built-in data types may be added in future versions.  If you
+need a specialized data type that is not currently provided as a
+built-in type, you are encouraged to write your own user-defined data
+type and contribute it for distribution in a future release of Octave.
+
+@menu
+* Numeric Objects::             
+* String Objects::              
+* Data Structure Objects::      
+@end menu
+
+@node Numeric Objects, String Objects, Built-in Data Types, Built-in Data Types
+@subsection Numeric Objects
+@cindex numeric constant
+@cindex numeric value
+
+Octave's built-in numeric objects include real and complex scalars and
+matrices.  All built-in numeric data is currently stored as double
+precision numbers.  On systems that use the IEEE floating point format,
+values in the range of approximately
+@iftex
+@tex
+ $2.2251\times10^{-308}$ to $1.7977\times10^{308}$
+@end tex
+@end iftex
+@ifinfo
+ 2.2251e-308 to 1.7977e+308
+@end ifinfo
+ can be stored, and the relative precision is approximately
+@iftex
+@tex
+ $2.2204\times10^{-16}$.
+@end tex
+@end iftex
+@ifinfo
+ 2.2204e-16.
+@end ifinfo
+The exact values are given by the variables @code{realmin},
+@code{realmax}, and @code{eps}, respectively.
+
+Matrix objects can be of any size, and can be dynamically reshaped and
+resized.  It is easy to extract individual rows, columns, or submatrices
+using a variety of powerful indexing features.  @xref{Index Expressions}.
+
+@xref{Numeric Data Types}, for more information.
+
+@node String Objects, Data Structure Objects, Numeric Objects, Built-in Data Types
+@subsection String Objects
+@cindex strings
+@cindex character strings
+@opindex "
+@opindex '
+
+A character string in Octave consists of a sequence of characters
+enclosed in either double-quote or single-quote marks.  Internally,
+Octave currently stores strings as matrices of characters.  All the
+indexing operations that work for matrix objects also work for strings.
+
+@xref{Strings}, for more information.
+
+@node Data Structure Objects,  , String Objects, Built-in Data Types
+@subsection Data Structure Objects
+@cindex structures
+@cindex data structures
+
+Octave's data structure type can help you to organize related objects of
+different types.  The current implementation uses an associative array
+with indices limited to strings, but the syntax is more like C-style
+structures.
+
+@xref{Data Structures}, for more information.
+
+@node User-defined Data Types, Object Sizes, Built-in Data Types, Data Types
+@section User-defined Data Types
+@cindex user-defined data types
+@cindex data types, user-defined
+
+Someday I hope to expand this to include a complete description of
+Octave's mechanism for managing user-defined data types.  Until this
+feature is documented here, you will have to make do by reading the code
+in the @file{ov.h}, @file{ops.h}, and related files from Octave's
+@file{src} directory.
+
+@node Object Sizes,  , User-defined Data Types, Data Types
+@section Object Sizes
+
+The following functions allow you to determine the size of a variable or
+expression.  These functions are defined for all objects.  They return
+@minus{}1 when the operation doesn't make sense.  For example, Octave's
+data structure type doesn't have rows or columns, so the @code{rows} and
+@code{columns} functions return @minus{}1 for structure arguments.
+
+@deftypefn {Function File} {} columns (@var{a})
+Return the number of columns of @var{a}.
+@end deftypefn
+
+@deftypefn {Function File} {} rows (@var{a})
+Return the number of rows of @var{a}.
+@end deftypefn
+
+@deftypefn {Function File} {} length (@var{a})
+Return the number of rows of @var{a} or the number of columns of
+@var{a}, whichever is larger.
+@end deftypefn
+
+@deftypefn {Function File} {} size (@var{a}, @var{n})
+Return the number rows and columns of @var{a}.
+
+With one input argument and one output argument, the result is returned
+in a 2 element row vector.  If there are two output arguments, the
+number of rows is assigned to the first, and the number of columns to
+the second.  For example,
+
+@example
+@group
+size ([1, 2; 3, 4; 5, 6])
+     @result{} [ 3, 2 ]
+
+[nr, nc] = size ([1, 2; 3, 4; 5, 6])
+     @result{} nr = 3
+     @result{} nc = 2
+@end group
+@end example
+
+If given a second argument of either 1 or 2, @code{size} will return
+only the row or column dimension.  For example
+
+@example
+size ([1, 2; 3, 4; 5, 6], 2)
+     @result{} 2
+@end example
+
+@noindent
+returns the number of columns in the given matrix.
+@end deftypefn
+
+@deftypefn {Function File} {} isempty (@var{a})
+Return 1 if @var{a} is an empty matrix (either the number of rows, or
+the number of columns, or both are zero).  Otherwise, return 0.
+@end deftypefn
+