Arbeiten mit Klassen/Unterklassen in Octave

WICHTIG: Der Betrieb von goMatlab.de wird privat finanziert fortgesetzt. - Mehr Infos...

Partner:

Forum

Option

[Erweitert]

• Diese Seite per Mail weiterempfehlen

Gehe zu:

MrEpsilon

Forum-Newbie


	Beiträge: 8

	Anmeldedatum: 18.04.15

	Wohnort: ---

	Version: ---

Verfasst am: 23.04.2015, 21:18 Titel: Arbeiten mit Klassen/Unterklassen in Octave

Hi ich würde gerne mit der Klasse Heaps in octave arbeiten. Nun habe ich folgende Matlab implementierungen der Klassen gefunden:
die Unterklasse :MinHeap:

Code:

classdef MinHeap < Heap
%--------------------------------------------------------------------------
% Class: MinHeap < Heap (& handle)
%
% Constructor: H = MinHeap(n);
% H = MinHeap(n,x0);
%
% Properties: (none)
%
% Methods: H.InsertKey(key);
% sx = H.Sort();
% min = H.ReturnMin();
% min = H.ExtractMin();
% count = H.Count();
% capacity = H.Capacity();
% bool = H.IsEmpty();
% bool = H.IsFull();
% H.Clear();
%
% Description: This class implements a min-heap of numeric keys
%
% Author: Brian Moore
% brimoor@umich.edu
%
% Date: January 16, 2014
%--------------------------------------------------------------------------

%
% Public methods
%
methods (Access = public)
%
% Constructor
%
function this = MinHeap(varargin)
%----------------------- Constructor --------------------------
% Syntax: H = MinHeap(n);
% H = MinHeap(n,x0);
%
% Inputs: n is the maximum number of keys that H can hold
%
% x0 is a vector (of length <= n) of numeric keys
% to insert into the heap during initialization
%
% Description: Creates a min-heap with capacity n
%--------------------------------------------------------------

% Call base class constructor
this=this@Heap( varargin{:});

% Construct the min heap
this.BuildMinHeap();
end

%
% Insert key
%
function InsertKey(this,key)
%------------------------ InsertKey ---------------------------
% Syntax: H.InsertKey(key);
%
% Inputs: key is a number
%
% Description: Inserts key into H
%--------------------------------------------------------------

this.SetLength(this.k + 1);
this.x(this.k) = inf;
this.DecreaseKey(this.k,key);
end

%
% Sort the heap
%
function sx = Sort(this)
%-------------------------- Sort ------------------------------
% Syntax: sx = H.Sort();
%
% Outputs: sx is a vector taht contains the sorted
% (ascending order) keys in H
%
% Description: Returns the sorted values in H
%--------------------------------------------------------------

% Sort the heap
nk = this.k; % virtual heap size during sorting procedure
for i = this.k:-1:2
this.Swap(1,i);
nk = nk - 1;
this.MinHeapify(1,nk);
end
this.x(1:this.k) = flipud(this.x(1:this.k));
sx = this.x(1:this.k);
end

%
% Return minimum element
%
function min = ReturnMin(this)
%------------------------ ReturnMin ---------------------------
% Syntax: min = H.ReturnMin();
%
% Outputs: min is the minimum key in H
%
% Description: Returns the minimum key in H
%--------------------------------------------------------------

if (this.IsEmpty() == true)
min = [];
else
min = this.x(1);
end
end

%
% Extract minimum element
%
function min = ExtractMin(this)
%------------------------ ExtractMin --------------------------
% Syntax: min = H.ExtractMin();
%
% Outputs: min is the minimum key in H
%
% Description: Returns the minimum key in H and extracts it
% from the heap
%--------------------------------------------------------------

this.SetLength(this.k - 1);
min = this.x(1);
this.x(1) = this.x(this.k + 1);
this.MinHeapify(1);
end
end

%
% Private methods
%
methods (Access = private)
%
% Decrease key at index i
%
function DecreaseKey(this,i,key)
if (i > this.k)
% Index overflow error
MinHeap.IndexOverflowError();
elseif (key > this.x(i))
% Decrease key error
MinHeap.DecreaseKeyError();
end
this.x(i) = key;
while ((i > 1) && (this.x(Heap.parent(i)) > this.x(i)))
this.Swap(i,Heap.parent(i));
i = Heap.parent(i);
end
end

%
% Build the min heap
%
function BuildMinHeap(this)
for i = floor(this.k / 2):-1:1
this.MinHeapify(i);
end
end

%
% Maintain the min heap property at a given node
%
function MinHeapify(this,i,size)
% Parse inputs
if (nargin < 3)
size = this.k;
end

ll = Heap.left(i);
rr = Heap.right(i);
if ((ll <= size) && (this.x(ll) < this.x(i)))
smallest = ll;
else
smallest = i;
end
if ((rr <= size) && (this.x(rr) < this.x(smallest)))
smallest = rr;
end
if (smallest ~= i)
this.Swap(i,smallest);
this.MinHeapify(smallest,size);
end
end
end

%
% Private static methods
%
methods (Access = private, Static = true)
%
% Decrease key error
%
function DecreaseKeyError()
error('You can only decrease keys in MinHeap');
end

%
% Index overflow error
%
function IndexOverflowError()
error('MinHeap index overflow');
end
end
end

Funktion ohne Link?

und die Superklasse dazu: Heap:

Code:

classdef Heap < handle
%
% Abstract superclass for all heap classes
%
% Note: You cannot instantiate Heap objects directly; use MaxHeap or
% MinHeap
%

%
% Protected properties
%
properties (Access = protected)
k; % current number of elements
n; % heap capacity
x; % heap array
end

%
% Public methods
%
methods (Access = public)
%
% Constructor
%
function this = Heap(n,x0)
% Initialize heap
if (n == 0)
Heap.ZeroCapacityError();
end
this.n = n;
this.x = nan(n,1);

if ((nargin == 2) && ~isempty(x0))
% Insert given elements
k0 = numel(x0);
if (k0 > n)
% Heap overflow
Heap.OverflowError();
else
this.x(1:k0) = x0(:);
this.SetLength(k0);
end
else
% Empty heap
this.Clear();
end
end

%
% Return number of elements in heap
%
function count = Count(this)
%-------------------------- Count -----------------------------
% Syntax: count = H.Count();
%
% Outputs: count is the number of values in H
%
% Description: Returns the number of values in H
%--------------------------------------------------------------

count = this.k;
end

%
% Return heap capacity
%
function capacity = Capacity(this)
%------------------------- Capacity ---------------------------
% Syntax: capacity = H.Capacity();
%
% Outputs: capacity is the size of H
%
% Description: Returns the maximum number of values that can
% fit in H
%--------------------------------------------------------------

capacity = this.n;
end

%
% Check for empty heap
%
function bool = IsEmpty(this)
%------------------------- IsEmpty ----------------------------
% Syntax: bool = H.IsEmpty();
%
% Outputs: bool = {true,false}
%
% Description: Determines if H is empty
%--------------------------------------------------------------

if (this.k == 0)
bool = true;
else
bool = false;
end
end

%
% Check for full heap
%
function bool = IsFull(this)
%-------------------------- IsFull ----------------------------
% Syntax: bool = H.IsFull();
%
% Outputs: bool = {true,false}
%
% Description: Determines if H is full
%--------------------------------------------------------------

if (this.k == this.n)
bool = true;
else
bool = false;
end
end

%
% Clear the heap
%
function Clear(this)
%-------------------------- Clear -----------------------------
% Syntax: H.Clear();
%
% Description: Removes all values from H
%--------------------------------------------------------------

this.SetLength(0);
end
end

%
% Abstract methods
%
methods (Abstract)
%
% Sort elements
%
Sort(this);

%
% Insert key
%
InsertKey(this,key);
end

%
% Protected methods
%
methods (Access = protected)
%
% Swap elements
%
function Swap(this,i,j)
val = this.x(i);
this.x(i) = this.x(j);
this.x(j) = val;
end

%
% Set length
%
function SetLength(this,k)
if (k < 0)
Heap.UnderflowError();
elseif (k > this.n)
Heap.OverflowError();
end
this.k = k;
end
end

%
% Protected static methods
%
methods (Access = protected, Static = true)
%
% Parent node
%
function p = parent(i)
p = floor(i / 2);
end

%
% Left child node
%
function l = left(i)
l = 2 * i;
end

% Right child node
function r = right(i)
r = 2 * i + 1;
end

%
% Overflow error
%
function OverflowError()
error('Heap overflow');
end

%
% Underflow error
%
function UnderflowError()
error('Heap underflow');
end

%
% No capacity error
%
function ZeroCapacityError()
error('Heap with no capacity is not allowed');
end
end
end

Funktion ohne Link?

Habe diese zwei klassen in den selben ordner gesteckt wie meinen Algorithmus, und wenn ich darin dann MinHeap definieren will kommt folgende Fehlermeldung:

Code:

>> H=MinHeap(n)
parse error near line 49 of file C:\Users\.....\Documents\OCTAVE\MinHeap.m

syntax error

>>> this = this@Heap(varargin{:});
^

>>

Funktion ohne Link?

Kann mir da wer weiterhelfen bzw. einen tipp geben?

markuman

Forum-Guru


	Beiträge: 320

	Anmeldedatum: 14.12.12

	Wohnort: ---

	Version: 2013a/2013b, Octave 3.6.4, 3.7.7

Verfasst am: 18.05.2015, 20:48 Titel:

classdef wird von Octave erst ab Version 4.0 unterstützt. Und dort auch lange noch nicht alles.
Dein Code liefert mit 4.0.0.RC4 z.B.

Code:

octave:1> H=MinHeap(1)
parse error near line 140 of file /tmp/c/Heap.m

external methods are only allowed in @-folders

>>> Sort(this);
^

error: class not found: Heap

Funktion ohne Link?

Demnach müsste man die Klasse Heap wohl in eine Klassische @ Struktur packen.
_________________

DIY OR DIE Cool

entropie=char(floor(94*rand(1, round(100.*rand)) + 32))
https://github.com/markuman


Einstellungen und Berechtigungen
Beiträge der letzten Zeit anzeigen:	Du kannst Beiträge in dieses Forum schreiben. Du kannst auf Beiträge in diesem Forum antworten. Du kannst deine Beiträge in diesem Forum nicht bearbeiten. Du kannst deine Beiträge in diesem Forum nicht löschen. Du kannst an Umfragen in diesem Forum nicht mitmachen. Du kannst Dateien in diesem Forum posten Du kannst Dateien in diesem Forum herunterladen

Impressum | Nutzungsbedingungen | Datenschutz | FAQ |

RSS

Hosted by:

Copyright © 2007 - 2024 goMatlab.de | Dies ist keine offizielle Website der Firma The Mathworks

MATLAB, Simulink, Stateflow, Handle Graphics, Real-Time Workshop, SimBiology, SimHydraulics, SimEvents, and xPC TargetBox are registered trademarks and The MathWorks, the L-shaped membrane logo, and Embedded MATLAB are trademarks of The MathWorks, Inc.