[prev in list] [next in list] [prev in thread] [next in thread]
List: kde-commits
Subject: [analitza/aucahuasi/matrixctrs] analitza: Minor improvements for Operations
From: Percy_Camilo_Triveño_Aucahuasi <percy.camilo.ta () gmail ! com>
Date: 2014-06-23 8:03:06
Message-ID: E1WyzDW-0000RS-U1 () scm ! kde ! org
[Download RAW message or body]
Git commit 7de2ffa31718688ac22559e6eace22d9f0e61b9e by Percy Camilo Triveño \
Aucahuasi. Committed on 23/06/2014 at 08:02.
Pushed by aucahuasi into branch 'aucahuasi/matrixctrs'.
Minor improvements for Operations
M +195 -192 analitza/operations.cpp
M +2 -2 analitza/operations.h
http://commits.kde.org/analitza/7de2ffa31718688ac22559e6eace22d9f0e61b9e
diff --git a/analitza/operations.cpp b/analitza/operations.cpp
index a0e75b9..ae7efd3 100644
--- a/analitza/operations.cpp
+++ b/analitza/operations.cpp
@@ -37,178 +37,6 @@
using namespace std;
using namespace Analitza;
-Cn* reduceUnaryComplex(Operator::OperatorType op, Cn* val, QString** correct)
-{
- const complex<double> a=val->complexValue();
-
- switch(op) {
- case Operator::minus:
- val->setValue(-a);
- break;
- case Operator::sin:
- val->setValue(sin(a));
- break;
- case Operator::cos:
- val->setValue(cos(a));
- break;
- case Operator::tan:
- val->setValue(tan(a));
- break;
- case Operator::sinh:
- val->setValue(sinh(a));
- break;
- case Operator::cosh:
- val->setValue(cosh(a));
- break;
- case Operator::tanh:
- val->setValue(tanh(a));
- break;
- case Operator::coth:
- val->setValue(cosh(a)/sinh(a));
- break;
- case Operator::exp:
- val->setValue(exp(a));
- break;
- case Operator::ln:
- val->setValue(log(a));
- break;
- case Operator::log:
- val->setValue(log10(a));
- break;
- case Operator::abs:
- val->setValue(std::abs(a));
- break;
- case Operator::conjugate:
- val->setValue(std::conj(a));
- break;
- case Operator::arg:
- val->setValue(std::arg(a));
- break;
- case Operator::real:
- val->setValue(a.real());
- break;
- case Operator::imaginary:
- val->setValue(a.imag());
- break;
- default:
- *correct=new QString(QCoreApplication::tr("Could not calculate a value \
%1").arg(Operator(op).toString()));
- }
- return val;
-}
-
-Cn* reduceUnaryReal(Operator::OperatorType op, Cn* oper, QString** correct)
-{
- const double a=oper->value();
-
- switch(op) {
- case Operator::minus:
- oper->setValue(-a);
- break;
- case Operator::factorial: {
- //Use gamma from math.h?
- uint res=1;
- for(int i=a; i>1.; i--) {
- res*=floor(i);
- }
- oper->setValue(res);
- } break;
- case Operator::sin:
- oper->setValue(sin(a));
- break;
- case Operator::cos:
- oper->setValue(cos(a));
- break;
- case Operator::tan:
- oper->setValue(tan(a));
- break;
- case Operator::sec:
- oper->setValue(1./cos(a));
- break;
- case Operator::csc:
- oper->setValue(1./sin(a));
- break;
- case Operator::cot:
- oper->setValue(1./tan(a));
- break;
- case Operator::sinh:
- oper->setValue(sinh(a));
- break;
- case Operator::cosh:
- oper->setValue(cosh(a));
- break;
- case Operator::tanh:
- oper->setValue(tanh(a));
- break;
- case Operator::sech:
- oper->setValue(1.0/cosh(a));
- break;
- case Operator::csch:
- oper->setValue(1.0/sinh(a));
- break;
- case Operator::coth:
- oper->setValue(cosh(a)/sinh(a));
- break;
- case Operator::arcsin:
- oper->setValue(asin(a));
- break;
- case Operator::arccos:
- oper->setValue(acos(a));
- break;
- case Operator::arctan:
- oper->setValue(atan(a));
- break;
- case Operator::arccot:
- oper->setValue(log(a+pow(a*a+1., 0.5)));
- break;
- case Operator::arcsinh: //see \
http://en.wikipedia.org/wiki/Inverse_hyperbolic_function
- oper->setValue(asinh(a));
- break;
- case Operator::arccosh:
- oper->setValue(acosh(a));
- break;
- case Operator::arccsc:
- oper->setValue(1/asin(a));
- break;
- case Operator::arccsch:
- oper->setValue(log(1/a+sqrt(1/(a*a)+1)));
- break;
- case Operator::arcsec:
- oper->setValue(1/(acos(a)));
- break;
- case Operator::arcsech:
- oper->setValue(log(1/a+sqrt(1/a+1)*sqrt(1/a-1)));
- break;
- case Operator::arctanh:
- oper->setValue(atanh(a));
- break;
- case Operator::exp:
- oper->setValue(exp(a));
- break;
- case Operator::ln:
- oper->setValue(log(a));
- break;
- case Operator::log:
- oper->setValue(log10(a));
- break;
- case Operator::abs:
- oper->setValue(a>=0. ? a : -a);
- break;
- case Operator::floor:
- oper->setValue(floor(a));
- break;
- case Operator::ceiling:
- oper->setValue(ceil(a));
- break;
- case Operator::_not:
- oper->setValue(!a);
- break;
- default:
- *correct=new QString(QCoreApplication::tr("Could not calculate a value \
%1").arg(Operator(op).toString()));
- break;
- }
- return oper;
-}
-
Cn* reduceRealReal(enum Operator::OperatorType op, Cn *oper, double a, double b, \
QString** correct) {
switch(op) {
@@ -444,7 +272,7 @@ Cn* reduceComplexComplex(enum Operator::OperatorType op, Cn \
*oper, complex<doubl return oper;
}
-Cn* Operations::reduceValueValue(enum Operator::OperatorType op, Cn *oper, const Cn \
*oper1, QString** correct) +Object* Operations::reduceValueValue(enum \
Operator::OperatorType op, Cn *oper, const Cn *oper1, QString** correct) {
if(Q_UNLIKELY(oper->isComplex() || oper1->isComplex())) {
const complex<double> a=oper->complexValue(), b=oper1->complexValue();
@@ -455,7 +283,179 @@ Cn* Operations::reduceValueValue(enum Operator::OperatorType \
op, Cn *oper, const }
}
-Cn* Operations::reduceUnaryValue(Operator::OperatorType op, Cn* oper, QString** \
correct) +Cn* reduceUnaryComplex(Operator::OperatorType op, Cn* val, QString** \
correct) +{
+ const complex<double> a=val->complexValue();
+
+ switch(op) {
+ case Operator::minus:
+ val->setValue(-a);
+ break;
+ case Operator::sin:
+ val->setValue(sin(a));
+ break;
+ case Operator::cos:
+ val->setValue(cos(a));
+ break;
+ case Operator::tan:
+ val->setValue(tan(a));
+ break;
+ case Operator::sinh:
+ val->setValue(sinh(a));
+ break;
+ case Operator::cosh:
+ val->setValue(cosh(a));
+ break;
+ case Operator::tanh:
+ val->setValue(tanh(a));
+ break;
+ case Operator::coth:
+ val->setValue(cosh(a)/sinh(a));
+ break;
+ case Operator::exp:
+ val->setValue(exp(a));
+ break;
+ case Operator::ln:
+ val->setValue(log(a));
+ break;
+ case Operator::log:
+ val->setValue(log10(a));
+ break;
+ case Operator::abs:
+ val->setValue(std::abs(a));
+ break;
+ case Operator::conjugate:
+ val->setValue(std::conj(a));
+ break;
+ case Operator::arg:
+ val->setValue(std::arg(a));
+ break;
+ case Operator::real:
+ val->setValue(a.real());
+ break;
+ case Operator::imaginary:
+ val->setValue(a.imag());
+ break;
+ default:
+ *correct=new QString(QCoreApplication::tr("Could not calculate a value \
%1").arg(Operator(op).toString())); + }
+ return val;
+}
+
+Cn* reduceUnaryReal(Operator::OperatorType op, Cn* oper, QString** correct)
+{
+ const double a=oper->value();
+
+ switch(op) {
+ case Operator::minus:
+ oper->setValue(-a);
+ break;
+ case Operator::factorial: {
+ //Use gamma from math.h?
+ uint res=1;
+ for(int i=a; i>1.; i--) {
+ res*=floor(i);
+ }
+ oper->setValue(res);
+ } break;
+ case Operator::sin:
+ oper->setValue(sin(a));
+ break;
+ case Operator::cos:
+ oper->setValue(cos(a));
+ break;
+ case Operator::tan:
+ oper->setValue(tan(a));
+ break;
+ case Operator::sec:
+ oper->setValue(1./cos(a));
+ break;
+ case Operator::csc:
+ oper->setValue(1./sin(a));
+ break;
+ case Operator::cot:
+ oper->setValue(1./tan(a));
+ break;
+ case Operator::sinh:
+ oper->setValue(sinh(a));
+ break;
+ case Operator::cosh:
+ oper->setValue(cosh(a));
+ break;
+ case Operator::tanh:
+ oper->setValue(tanh(a));
+ break;
+ case Operator::sech:
+ oper->setValue(1.0/cosh(a));
+ break;
+ case Operator::csch:
+ oper->setValue(1.0/sinh(a));
+ break;
+ case Operator::coth:
+ oper->setValue(cosh(a)/sinh(a));
+ break;
+ case Operator::arcsin:
+ oper->setValue(asin(a));
+ break;
+ case Operator::arccos:
+ oper->setValue(acos(a));
+ break;
+ case Operator::arctan:
+ oper->setValue(atan(a));
+ break;
+ case Operator::arccot:
+ oper->setValue(log(a+pow(a*a+1., 0.5)));
+ break;
+ case Operator::arcsinh: //see \
http://en.wikipedia.org/wiki/Inverse_hyperbolic_function + \
oper->setValue(asinh(a)); + break;
+ case Operator::arccosh:
+ oper->setValue(acosh(a));
+ break;
+ case Operator::arccsc:
+ oper->setValue(1/asin(a));
+ break;
+ case Operator::arccsch:
+ oper->setValue(log(1/a+sqrt(1/(a*a)+1)));
+ break;
+ case Operator::arcsec:
+ oper->setValue(1/(acos(a)));
+ break;
+ case Operator::arcsech:
+ oper->setValue(log(1/a+sqrt(1/a+1)*sqrt(1/a-1)));
+ break;
+ case Operator::arctanh:
+ oper->setValue(atanh(a));
+ break;
+ case Operator::exp:
+ oper->setValue(exp(a));
+ break;
+ case Operator::ln:
+ oper->setValue(log(a));
+ break;
+ case Operator::log:
+ oper->setValue(log10(a));
+ break;
+ case Operator::abs:
+ oper->setValue(a>=0. ? a : -a);
+ break;
+ case Operator::floor:
+ oper->setValue(floor(a));
+ break;
+ case Operator::ceiling:
+ oper->setValue(ceil(a));
+ break;
+ case Operator::_not:
+ oper->setValue(!a);
+ break;
+ default:
+ *correct=new QString(QCoreApplication::tr("Could not calculate a value \
%1").arg(Operator(op).toString())); + break;
+ }
+ return oper;
+}
+
+Object* Operations::reduceUnaryValue(Operator::OperatorType op, Cn* oper, QString** \
correct) {
if(Q_UNLIKELY(oper->isComplex()))
return reduceUnaryComplex(op, oper, correct);
@@ -672,24 +672,28 @@ Object* Operations::reduceVectorMatrix(Operator::OperatorType \
op, Vector* vector {
Object* ret = 0;
if (op == Operator::times) {
- //TODO check if matrix has only values as type for entries
- if (1 == matrix->rowCount()) {
- const int m = vector->size();
- const int n = matrix->columnCount();
-
- Matrix *newmat = new Matrix();
-
- for (int i = 0; i < m; ++i) {
- MatrixRow *row = new MatrixRow(n);
- for (int j = 0; j < n; ++j)
- row->appendBranch(reduceValueValue(op, (Cn*)vector->at(i), \
(Cn*)matrix->at(0,j), correct)->copy()); + if (vector->hasOnlyNumbers() && \
matrix->hasOnlyNumbers()) { + if (1 == matrix->rowCount()) {
+ const int m = vector->size();
+ const int n = matrix->columnCount();
+
+ Matrix *newmat = new Matrix();
+
+ for (int i = 0; i < m; ++i) {
+ MatrixRow *row = new MatrixRow(n);
+ for (int j = 0; j < n; ++j)
+ row->appendBranch(reduceValueValue(op, (Cn*)vector->at(i), \
(Cn*)matrix->at(0,j), correct)->copy()); +
+ newmat->appendBranch(row);
+ }
- newmat->appendBranch(row);
+ ret = newmat;
+ } else {
+ *correct=new QString(QCoreApplication::tr("Multiplication between a vector and a \
matrix is allowed provided that the matrix has only one matrixrow element")); \
+ ret=new None(); }
-
- ret = newmat;
} else {
- *correct=new QString(QCoreApplication::tr("Multiplication between a vector and a \
matrix is allowed provided that the matrix has only one matrixrow element")); \
+ *correct=new QString(QCoreApplication::tr("Matrix and vector entries must be \
numbers")); ret=new None();
}
}
@@ -697,7 +701,6 @@ Object* Operations::reduceVectorMatrix(Operator::OperatorType op, \
Vector* vector return ret;
}
-
Object* Operations::reduceMatrixMatrix(Operator::OperatorType op, Matrix* m1, \
Matrix* m2, QString** correct) {
Object* ret = 0;
@@ -836,8 +839,8 @@ Object* Operations::reduceMatrixValue(Operator::OperatorType op, \
Matrix* matrix, }
ret = products[len];
- //NOTE free memory (at 0 we have matrix and the last is our result, so go \
from 1 to len-1)
- for (i = 1; i < len; i++)
+ //NOTE free the memory, except products[len]
+ for (i = 0; i < len; i++)
delete products[i];
} else { // else: use Exponentiation by squaring
Matrix *product = Matrix::identity(base->rowCount());
diff --git a/analitza/operations.h b/analitza/operations.h
index 9b6e690..d0f775a 100644
--- a/analitza/operations.h
+++ b/analitza/operations.h
@@ -53,8 +53,8 @@ class Operations
static Object* reduceValueNone(Operator::OperatorType op, Cn* oper, None *cntr, \
QString** correct); static Object* reduceNoneValue(Operator::OperatorType op, None \
*cntr, Cn* oper, QString** correct);
- static Cn* reduceValueValue(Operator::OperatorType op, Cn *oper, const Cn* oper1, \
QString** correct);
- static Cn* reduceUnaryValue(Operator::OperatorType op, Cn *oper, QString** \
correct); + static Object* reduceValueValue(Operator::OperatorType op, Cn *oper, \
const Cn* oper1, QString** correct); + static Object* \
reduceUnaryValue(Operator::OperatorType op, Cn *oper, QString** correct);
static Object* reduceValueVector(Operator::OperatorType op, Cn *oper, Vector* \
vector, QString** correct); static Object* reduceVectorValue(Operator::OperatorType \
op, Vector* vector, Cn *oper, QString** correct);
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic