GNU Octave öncelikle numerik hesaplamalara yönelik yüksek seviyeli bir dildir. Çoğunlukla Matlab ile uyumlu bir dil kullanarak lineer (doğrusal) ve lineer olmayan problemleri numerik olarak çözmeye ve başka numerik deneyler yapmaya elverişli bir komut satırı arayüzü temin etmektedir.

1 Octave’a Kısa Bir Giriş

Bu kılavuz GNU Octave’ın nasıl kurulacağını, çalıştırılacağını ve kullanılacağını ve hataların nasıl rapor edileceğini göstermektedir.

GNU Octave öncelikle numerik hesaplamalara yönelik yüksek düzey bir dildir. Lineer (doğrusal) ve lineer olmayan problemleri numerik olarak çözmeye ve başka numerik deneyler yapmaya elverişli bir komut satırı arayüzü temin etmektedir. Batch-uyumlu bir dil olarak da kullanılabilir.

GNU Octave aynı zamanda yeniden dağıtımı serbest olan bir yazılımdır. Özgür Yazılım Kurumu tarafından yayınlandığı üzere GNU Genel Kamu Lisansı (GPL) şartlarına uygun olarak yeniden dağıtımını yapabilir ve/veya değiştirebilirsiniz. GPL bu kılavuzda Kopyalama’nın içinde yer almaktadır.

Bu kılavuz Octave 2.9.12+ sürümü ile uyumludur.

A numeric constant may be a scalar, a vector, or a matrix, and it may contain complex values.

The simplest form of a numeric constant, a scalar, is a single number that can be an integer, a decimal fraction, a number in scientific (exponential) notation, or a complex number. Note that by default numeric constants are represented within Octave in double-precision floating point format (complex constants are stored as pairs of double-precision floating point values). It is however possible to represent real integers as described in Integer Data Types. Here are some examples of real-valued numeric constants, which all have the same value:

Elements of structures can be of any value type. For example, the three expressions

As an example, the following code creates a cell array containing a string and a 2-by-2 random matrix

An expression can serve as a statement on its own. Most other kinds of statements contain one or more expressions which specify data to be operated on. As in other languages, expressions in Octave include variables, array references, constants, and function calls, as well as combinations of these with various operators.

Normally, you evaluate expressions simply by typing them at the Octave prompt, or by asking Octave to interpret commands that you have saved in a file.

Sometimes, you may find it necessary to evaluate an expression that has been computed and stored in a string, which is exactly what the eval lets you do.

Control statements such as if, while, and so on control the flow of execution in Octave programs. All the control statements start with special keywords such as if and while, to distinguish them from simple expressions. Many control statements contain other statements; for example, the if statement contains another statement which may or may not be executed.

Each control statement has a corresponding end statement that marks the end of the end of the control statement. For example, the keyword endif marks the end of an if statement, and endwhile marks the end of a while statement. You can use the keyword end anywhere a more specific end keyword is expected, but using the more specific keywords is preferred because if you use them, Octave is able to provide better diagnostics for mismatched or missing end tokens.

The list of statements contained between keywords like if or while and the corresponding end statement is called the body of a control statement.

Octave includes several functions for printing error and warning messages. When you write functions that need to take special action when they encounter abnormal conditions, you should print the error messages using the functions described in this chapter.

Since many of Octave's functions use these functions, it is also useful to understand them, so that errors and warnings can be handled.

Octave includes a built-in debugger to aid in the development of scripts. This can be used to interrupt the execution of an Octave script at a certain point, or when certain conditions are met. Once execution has stopped, and debug mode is entered, the symbol table at the point where execution has stopped can be examined and modified to check for errors.

The normal commandline editing and history functions are available in debug mode. However, one limitation on the debug mode is that commands entered at the debug prompt are evaluated as strings, rather than being handled by the Octave parser. This means that all commands in debug mode must be contained on a single line. That is, it is alright to write

Octave provides the following functions for bit twiddling.

     F (x) = 0

using the function fsolve, which is based on the Minpack subroutine hybrd.

Octave has support for various statistical methods. This includes basic descriptive statistics, statistical tests, random number generation, and much more.

The functions that analyze data all assume that multidimensional data is arranged in a matrix where each row is an observation, and each column is a variable. So, the matrix defined by

     a = [ 0.9, 0.7;
           0.1, 0.1;
           0.5, 0.4 ];

contains three observations from a two-dimensional distribution. While this is the default data arrangement, most functions support different arrangements.

It should be noted that the statistics functions doesn't handle data containing NaN, NA, or Inf. Such values needs to be handled explicitly.

Return the future value at the end of period n of an investment which consists of n payments of p in each period, assuming an interest rate r.

The optional argument l may be used to specify an additional lump-sum payment.

The optional argument method may be used ot specify whether the payments are made at the end ("e", default) or at the beginning ("b") of each period.

Note that the rate r is specified as a fraction (i.e., 0.05, not 5 percent).

In Octave, a polynomial is represented by its coefficients (arranged in descending order). For example, a vector $c$ of length N

     p(x) = c(1) x^N + ... + c(N) x + c(N+1).

Determines area of a polygon by triangle method. The variables x and y define the vertex pairs, and must therefore have the same shape. Then might be either vectors or arrays. If they are arrays then the columns of x and y are treated seperately and an area returned for each.

If the optional dim argument is given, then polyarea works along this dimension of the arrays x and y.

The Octave Control Systems Toolbox (OCST) was initially developed by Dr. A. Scottedward Hodel This e-mail address is being protected from spambots. You need JavaScript enabled to view it with the assistance of his students

• R. Bruce Tenison This e-mail address is being protected from spambots. You need JavaScript enabled to view it ,
• David C. Clem,
• John E. Ingram This e-mail address is being protected from spambots. You need JavaScript enabled to view it , and
• Kristi McGowan.

Before going further, you should first determine if you really need to use dynamically linked functions at all. Before proceeding with writing any dynamically linked function to improve performance you should address ask yourself

• Can I get the same functionality using the Octave scripting language only.
• Is it thoroughly optimized Octave code? Vectorization of Octave code, doesn't just make it concise, it generally significantly improves its performance. Above all, if loops must be used, make sure that the allocation of space for variables takes place outside the loops using an assignment to a like matrix or zeros.
• Does it make as much use as possible of existing built-in library routines? These are highly optimized and many do not carry the overhead of being interpreted.
• Does writing a dynamically linked function represent useful investment of your time, relative to staying in Octave?

Also, as oct- and mex-files are dynamically linked to octave, they introduce to possibility of having Octave abort due to coding errors in the user code. For example a segmentation violation in the users code will cause Octave to abort.

Some of these problems are due to bugs in other software, some are missing features that are too much work to add, and some are places where people's opinions differ as to what is best.

Here is the procedure for installing Octave from scratch on a Unix system.

Run the shell script configure. This will determine the features your system has (or doesn't have) and create a file named Makefile from each of the files named Makefile.in.

The development of Octave code can greatly be facilitated using Emacs with Octave mode, a major mode for editing Octave files which can e.g. automatically indent the code, do some of the typing (with Abbrev mode) and show keywords, comments, strings, etc. in different faces (with Font-lock mode on devices that support it).

It is also possible to run Octave from within Emacs, either by directly entering commands at the prompt in a buffer in Inferior Octave mode, or by interacting with Octave from within a file with Octave code. This is useful in particular for debugging Octave code.

Finally, you can convince Octave to use the Emacs info reader for help -i.

All functionality is provided by the Emacs Lisp package EOS (for “Emacs Octave Support”). This chapter describes how to set up and use this package.

Please contact < This e-mail address is being protected from spambots. You need JavaScript enabled to view it > if you have any questions or suggestions on using EOS.