← Back to branch summary

~ubuntu-branches/debian/sid/octave3.0/sid

« back to all changes in this revision

Viewing changes to src/OPERATORS/op-sm-m.cc

  • Committer: Bazaar Package Importer
  • Author(s): Rafael Laboissiere
  • Date: 2007-12-23 16:04:15 UTC
  • Revision ID: james.westby@ubuntu.com-20071223160415-n4gk468dihy22e9v
Tags: upstream-3.0.0
Import upstream version 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/OPERATORS/op-sm-m.cc
 
1
/*
 
2
 
 
3
Copyright (C) 2004, 2005, 2006, 2007 David Bateman
 
4
Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004 Andy Adler
 
5
 
 
6
This file is part of Octave.
 
7
 
 
8
Octave is free software; you can redistribute it and/or modify it
 
9
under the terms of the GNU General Public License as published by the
 
10
Free Software Foundation; either version 3 of the License, or (at your
 
11
option) any later version.
 
12
 
 
13
Octave is distributed in the hope that it will be useful, but WITHOUT
 
14
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 
15
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 
16
for more details.
 
17
 
 
18
You should have received a copy of the GNU General Public License
 
19
along with Octave; see the file COPYING.  If not, see
 
20
<http://www.gnu.org/licenses/>.
 
21
 
 
22
*/
 
23
 
 
24
#ifdef HAVE_CONFIG_H
 
25
#include <config.h>
 
26
#endif
 
27
 
 
28
#include "gripes.h"
 
29
#include "oct-obj.h"
 
30
#include "ov.h"
 
31
#include "ov-typeinfo.h"
 
32
#include "ov-re-mat.h"
 
33
#include "ops.h"
 
34
#include "xdiv.h"
 
35
 
 
36
#include "sparse-xpow.h"
 
37
#include "sparse-xdiv.h"
 
38
#include "smx-sm-m.h"
 
39
#include "smx-m-sm.h"
 
40
#include "ov-re-sparse.h"
 
41
 
 
42
// sparse matrix by matrix ops.
 
43
 
 
44
DEFBINOP_OP (add, sparse_matrix, matrix, +)
 
45
DEFBINOP_OP (sub, sparse_matrix, matrix, -)
 
46
 
 
47
DEFBINOP_OP (mul, sparse_matrix, matrix, *)
 
48
 
 
49
DEFBINOP (div, sparse_matrix, matrix)
 
50
{
 
51
  CAST_BINOP_ARGS (const octave_sparse_matrix&, const octave_matrix&);
 
52
  MatrixType typ = v2.matrix_type ();
 
53
  
 
54
  Matrix ret = xdiv (v1.matrix_value (), v2.matrix_value (), typ);
 
55
 
 
56
  v2.matrix_type (typ);
 
57
  return ret;
 
58
}
 
59
 
 
60
DEFBINOPX (pow, sparse_matrix, matrix)
 
61
{
 
62
  error ("can't do A ^ B for A and B both matrices");
 
63
  return octave_value ();
 
64
}
 
65
 
 
66
DEFBINOP (ldiv, sparse_matrix, matrix)
 
67
{
 
68
  CAST_BINOP_ARGS (const octave_sparse_matrix&, const octave_matrix&);
 
69
 
 
70
  if (v1.rows() == 1 && v1.columns() == 1)
 
71
    {
 
72
      double d = v1.scalar_value ();
 
73
 
 
74
      if (d == 0.0)
 
75
        gripe_divide_by_zero ();
 
76
 
 
77
      return octave_value (v2.array_value () / d);
 
78
    }
 
79
  else
 
80
    {
 
81
      MatrixType typ = v1.matrix_type ();
 
82
 
 
83
      Matrix ret = xleftdiv (v1.sparse_matrix_value (), 
 
84
                             v2.matrix_value (), typ);
 
85
 
 
86
      v1.matrix_type (typ);
 
87
      return ret;
 
88
    }
 
89
}
 
90
 
 
91
DEFBINOP_FN (lt, sparse_matrix, matrix, mx_el_lt)
 
92
DEFBINOP_FN (le, sparse_matrix, matrix, mx_el_le)
 
93
DEFBINOP_FN (eq, sparse_matrix, matrix, mx_el_eq)
 
94
DEFBINOP_FN (ge, sparse_matrix, matrix, mx_el_ge)
 
95
DEFBINOP_FN (gt, sparse_matrix, matrix, mx_el_gt)
 
96
DEFBINOP_FN (ne, sparse_matrix, matrix, mx_el_ne)
 
97
 
 
98
DEFBINOP_FN (el_mul, sparse_matrix, matrix, product)
 
99
DEFBINOP_FN (el_div, sparse_matrix, matrix, quotient)
 
100
 
 
101
DEFBINOP (el_pow, sparse_matrix, matrix)
 
102
{
 
103
  CAST_BINOP_ARGS (const octave_sparse_matrix&, const octave_matrix&);
 
104
  
 
105
  return octave_value (elem_xpow (v1.sparse_matrix_value (), 
 
106
                                  SparseMatrix (v2.matrix_value ())));
 
107
}
 
108
 
 
109
DEFBINOP (el_ldiv, sparse_matrix, matrix)
 
110
{
 
111
  CAST_BINOP_ARGS (const octave_sparse_matrix&, const octave_matrix&);
 
112
  
 
113
  return octave_value
 
114
    (quotient (v2.matrix_value (), v1.sparse_matrix_value ()));
 
115
}
 
116
 
 
117
DEFBINOP_FN (el_and, sparse_matrix, matrix, mx_el_and)
 
118
DEFBINOP_FN (el_or,  sparse_matrix, matrix, mx_el_or)
 
119
 
 
120
DEFCATOP (sm_m, sparse_matrix, matrix)
 
121
{
 
122
  CAST_BINOP_ARGS (octave_sparse_matrix&, const octave_matrix&);
 
123
  SparseMatrix tmp (v2.matrix_value ());
 
124
  return octave_value (v1.sparse_matrix_value (). concat (tmp, ra_idx));
 
125
}
 
126
 
 
127
DEFASSIGNOP (assign, sparse_matrix, matrix)
 
128
{
 
129
  CAST_BINOP_ARGS (octave_sparse_matrix&, const octave_matrix&);
 
130
 
 
131
  SparseMatrix tmp (v2.matrix_value ());
 
132
  v1.assign (idx, tmp);
 
133
  return octave_value ();
 
134
}
 
135
 
 
136
void
 
137
install_sm_m_ops (void)
 
138
{
 
139
  INSTALL_BINOP (op_add, octave_sparse_matrix, octave_matrix, add);
 
140
  INSTALL_BINOP (op_sub, octave_sparse_matrix, octave_matrix, sub);
 
141
  INSTALL_BINOP (op_mul, octave_sparse_matrix, octave_matrix, mul);
 
142
  INSTALL_BINOP (op_div, octave_sparse_matrix, octave_matrix, div);
 
143
  INSTALL_BINOP (op_pow, octave_sparse_matrix, octave_matrix, pow);
 
144
  INSTALL_BINOP (op_ldiv, octave_sparse_matrix, octave_matrix, ldiv);
 
145
  INSTALL_BINOP (op_lt, octave_sparse_matrix, octave_matrix, lt);
 
146
  INSTALL_BINOP (op_le, octave_sparse_matrix, octave_matrix, le);
 
147
  INSTALL_BINOP (op_eq, octave_sparse_matrix, octave_matrix, eq);
 
148
  INSTALL_BINOP (op_ge, octave_sparse_matrix, octave_matrix, ge);
 
149
  INSTALL_BINOP (op_gt, octave_sparse_matrix, octave_matrix, gt);
 
150
  INSTALL_BINOP (op_ne, octave_sparse_matrix, octave_matrix, ne);
 
151
  INSTALL_BINOP (op_el_mul, octave_sparse_matrix, octave_matrix, el_mul);
 
152
  INSTALL_BINOP (op_el_div, octave_sparse_matrix, octave_matrix, el_div);
 
153
  INSTALL_BINOP (op_el_pow, octave_sparse_matrix, octave_matrix, el_pow);
 
154
  INSTALL_BINOP (op_el_ldiv, octave_sparse_matrix, octave_matrix, el_ldiv);
 
155
  INSTALL_BINOP (op_el_and, octave_sparse_matrix, octave_matrix, el_and);
 
156
  INSTALL_BINOP (op_el_or, octave_sparse_matrix, octave_matrix,  el_or);
 
157
 
 
158
  INSTALL_CATOP (octave_sparse_matrix, octave_matrix, sm_m);
 
159
 
 
160
  INSTALL_ASSIGNOP (op_asn_eq, octave_sparse_matrix, octave_matrix, assign);
 
161
}
 
162
 
 
163
/*
 
164
;;; Local Variables: ***
 
165
;;; mode: C++ ***
 
166
;;; End: ***
 
167
*/