Ernesto Palacios / Matrix

Matrix Library. v1.6.4

Dependents:   Matrix_class Wizardsneverdie TwoTank mbed_multiplex_matrix ... more

Operators.cpp@5:a4014ab0a8cf, 2011-10-30 (annotated)

Committer:
Yo_Robot
Date:
Sun Oct 30 16:29:23 2011 +0000
Revision:
5:a4014ab0a8cf
Parent:
3:589fb80932b5 
Version 1.6.4  View Log.c for changes.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Yo_Robot 3:589fb80932b5 1 /**
Yo_Robot 5:a4014ab0a8cf 2 * @brief Source Code for the Operator of Matrix Class.
Yo_Robot 5:a4014ab0a8cf 3 * @file Operators.cpp
Yo_Robot 3:589fb80932b5 4 * @author Ernesto Palacios
Yo_Robot 5:a4014ab0a8cf 5 *
Yo_Robot 3:589fb80932b5 6 * Created on September 2011.
Yo_Robot 3:589fb80932b5 7 *
Yo_Robot 5:a4014ab0a8cf 8 * Develop Under GPL v3.0 License
Yo_Robot 5:a4014ab0a8cf 9 * http://www.gnu.org/licenses/gpl-3.0.html
Yo_Robot 5:a4014ab0a8cf 10 *
Yo_Robot 3:589fb80932b5 11 */
Yo_Robot 3:589fb80932b5 12 #include "mbed.h"
Yo_Robot 3:589fb80932b5 13 #include "Matrix.h"
Yo_Robot 3:589fb80932b5 14
Yo_Robot 5:a4014ab0a8cf 15 /// Subindex in Matrix left side
Yo_Robot 5:a4014ab0a8cf 16 float& Matrix::operator ()(int row, int col)
Yo_Robot 5:a4014ab0a8cf 17 {
Yo_Robot 5:a4014ab0a8cf 18 --row; --col;
Yo_Robot 5:a4014ab0a8cf 19
Yo_Robot 5:a4014ab0a8cf 20 if( row >= _nRows || col >= _nCols)
Yo_Robot 5:a4014ab0a8cf 21 {
Yo_Robot 5:a4014ab0a8cf 22 printf("\n\nError:\nOut of limits @ Matrix::operator()\n");
Yo_Robot 5:a4014ab0a8cf 23 }else{
Yo_Robot 5:a4014ab0a8cf 24 return _matrix[row][col];
Yo_Robot 5:a4014ab0a8cf 25 }
Yo_Robot 5:a4014ab0a8cf 26 }
Yo_Robot 5:a4014ab0a8cf 27
Yo_Robot 5:a4014ab0a8cf 28 /// Subindex in Matrix right side
Yo_Robot 5:a4014ab0a8cf 29 float Matrix::operator ()(int row, int col) const
Yo_Robot 5:a4014ab0a8cf 30 {
Yo_Robot 5:a4014ab0a8cf 31 --row; --col;
Yo_Robot 5:a4014ab0a8cf 32
Yo_Robot 5:a4014ab0a8cf 33 if( row >= _nRows || col >= _nCols)
Yo_Robot 5:a4014ab0a8cf 34 {
Yo_Robot 5:a4014ab0a8cf 35 printf("\n\nError:\nOut of limits @ Matrix::operator()\n");
Yo_Robot 5:a4014ab0a8cf 36 }else{
Yo_Robot 5:a4014ab0a8cf 37 return _matrix[row][col];
Yo_Robot 5:a4014ab0a8cf 38 }
Yo_Robot 5:a4014ab0a8cf 39 }
Yo_Robot 5:a4014ab0a8cf 40
Yo_Robot 5:a4014ab0a8cf 41
Yo_Robot 3:589fb80932b5 42 /// Overloaded Asign Operator. Resizes Matrix
Yo_Robot 3:589fb80932b5 43 Matrix& Matrix::operator = ( const Matrix& rightM )
Yo_Robot 3:589fb80932b5 44 {
Yo_Robot 3:589fb80932b5 45 if (this != &rightM )
Yo_Robot 3:589fb80932b5 46 {
Yo_Robot 3:589fb80932b5 47
Yo_Robot 3:589fb80932b5 48 _nRows = rightM._nRows;
Yo_Robot 3:589fb80932b5 49 _nCols = rightM._nCols;
Yo_Robot 3:589fb80932b5 50
Yo_Robot 3:589fb80932b5 51 _matrix.resize( rightM._nRows );
Yo_Robot 3:589fb80932b5 52 for( int i = 0; i < rightM._nRows; i++ )
Yo_Robot 3:589fb80932b5 53 _matrix [i].resize(rightM._nCols);
Yo_Robot 3:589fb80932b5 54
Yo_Robot 3:589fb80932b5 55 for( int i = 0; i < _nRows; i++ )
Yo_Robot 3:589fb80932b5 56 for( int j = 0; j < _nCols; j++ )
Yo_Robot 3:589fb80932b5 57 _matrix[i][j] = rightM._matrix[i][j];
Yo_Robot 3:589fb80932b5 58 }
Yo_Robot 3:589fb80932b5 59 return *this;
Yo_Robot 3:589fb80932b5 60
Yo_Robot 3:589fb80932b5 61 }
Yo_Robot 3:589fb80932b5 62
Yo_Robot 3:589fb80932b5 63
Yo_Robot 3:589fb80932b5 64 const Matrix Matrix::operator -()
Yo_Robot 3:589fb80932b5 65 {
Yo_Robot 3:589fb80932b5 66 Matrix result( _nRows, _nCols );
Yo_Robot 3:589fb80932b5 67
Yo_Robot 3:589fb80932b5 68 for( int i = 0; i < _nRows; i++ )
Yo_Robot 3:589fb80932b5 69 for( int j = 0; j < _nCols; j++ )
Yo_Robot 3:589fb80932b5 70 result._matrix[i][j] = _matrix[i][j] * -1;
Yo_Robot 3:589fb80932b5 71
Yo_Robot 3:589fb80932b5 72 return result;
Yo_Robot 3:589fb80932b5 73 }
Yo_Robot 3:589fb80932b5 74
Yo_Robot 5:a4014ab0a8cf 75
Yo_Robot 5:a4014ab0a8cf 76 /// Comapre element by element
Yo_Robot 5:a4014ab0a8cf 77 bool operator == ( const Matrix& leftM, const Matrix& rightM )
Yo_Robot 5:a4014ab0a8cf 78 {
Yo_Robot 5:a4014ab0a8cf 79 if( leftM._nRows == rightM._nRows && leftM._nCols == rightM._nCols )
Yo_Robot 5:a4014ab0a8cf 80 {
Yo_Robot 5:a4014ab0a8cf 81 bool equal = false;
Yo_Robot 5:a4014ab0a8cf 82
Yo_Robot 5:a4014ab0a8cf 83 for( int i = 0; i < leftM._nRows; i++ )
Yo_Robot 5:a4014ab0a8cf 84 for( int j = 0; j < leftM._nCols; j++ )
Yo_Robot 5:a4014ab0a8cf 85 if( leftM._matrix[i][j] != rightM._matrix[i][j] )
Yo_Robot 5:a4014ab0a8cf 86 equal = equal || true;
Yo_Robot 5:a4014ab0a8cf 87
Yo_Robot 5:a4014ab0a8cf 88 return !equal;
Yo_Robot 5:a4014ab0a8cf 89
Yo_Robot 5:a4014ab0a8cf 90 }else{ return false; }
Yo_Robot 5:a4014ab0a8cf 91 }
Yo_Robot 5:a4014ab0a8cf 92
Yo_Robot 5:a4014ab0a8cf 93
Yo_Robot 5:a4014ab0a8cf 94 /// Calls for '==' operator
Yo_Robot 5:a4014ab0a8cf 95 bool operator != ( const Matrix& leftM, const Matrix& rightM )
Yo_Robot 5:a4014ab0a8cf 96 {
Yo_Robot 5:a4014ab0a8cf 97 return !( leftM == rightM );
Yo_Robot 5:a4014ab0a8cf 98 }
Yo_Robot 5:a4014ab0a8cf 99
Yo_Robot 5:a4014ab0a8cf 100
Yo_Robot 5:a4014ab0a8cf 101 /// Matrices must be same size.
Yo_Robot 5:a4014ab0a8cf 102 /// Element by element adition.
Yo_Robot 5:a4014ab0a8cf 103 Matrix& operator +=( Matrix& leftM, const Matrix& rightM )
Yo_Robot 5:a4014ab0a8cf 104 {
Yo_Robot 5:a4014ab0a8cf 105 if( leftM._nRows == rightM._nRows && leftM._nCols == rightM._nCols )
Yo_Robot 5:a4014ab0a8cf 106 {
Yo_Robot 5:a4014ab0a8cf 107 for( int i = 0; i < leftM._nRows; i++ )
Yo_Robot 5:a4014ab0a8cf 108 for( int j = 0; j < leftM._nCols; j++ )
Yo_Robot 5:a4014ab0a8cf 109 leftM._matrix[i][j] += rightM._matrix[i][j];
Yo_Robot 5:a4014ab0a8cf 110
Yo_Robot 5:a4014ab0a8cf 111 return leftM;
Yo_Robot 5:a4014ab0a8cf 112
Yo_Robot 5:a4014ab0a8cf 113 }else{ printf( "\n\nERROR:\nDiferent Dimensions @ += operator\n" ); }
Yo_Robot 5:a4014ab0a8cf 114 }
Yo_Robot 5:a4014ab0a8cf 115
Yo_Robot 5:a4014ab0a8cf 116
Yo_Robot 5:a4014ab0a8cf 117 /// Matrices must be same size.
Yo_Robot 5:a4014ab0a8cf 118 /// Element by element Substraction
Yo_Robot 5:a4014ab0a8cf 119 Matrix& operator -=( Matrix& leftM, const Matrix& rightM )
Yo_Robot 5:a4014ab0a8cf 120 {
Yo_Robot 5:a4014ab0a8cf 121 if( leftM._nRows == rightM._nRows && leftM._nCols == rightM._nCols )
Yo_Robot 5:a4014ab0a8cf 122 {
Yo_Robot 5:a4014ab0a8cf 123 for( int i = 0; i < leftM._nRows; i++ )
Yo_Robot 5:a4014ab0a8cf 124 for( int j = 0; j < leftM._nCols; j++ )
Yo_Robot 5:a4014ab0a8cf 125 leftM._matrix[i][j] -= rightM._matrix[i][j];
Yo_Robot 5:a4014ab0a8cf 126
Yo_Robot 5:a4014ab0a8cf 127 return leftM;
Yo_Robot 5:a4014ab0a8cf 128
Yo_Robot 5:a4014ab0a8cf 129 }else{
Yo_Robot 5:a4014ab0a8cf 130 printf( "\n\nERROR:\nDiferent Dimensions @ -= operator\n" );
Yo_Robot 5:a4014ab0a8cf 131 }
Yo_Robot 5:a4014ab0a8cf 132 }
Yo_Robot 5:a4014ab0a8cf 133
Yo_Robot 5:a4014ab0a8cf 134
Yo_Robot 5:a4014ab0a8cf 135 Matrix& operator *=( Matrix& leftM, const Matrix& rightM )
Yo_Robot 5:a4014ab0a8cf 136 {
Yo_Robot 5:a4014ab0a8cf 137 if( leftM._nCols == rightM._nRows )
Yo_Robot 5:a4014ab0a8cf 138 {
Yo_Robot 5:a4014ab0a8cf 139 Matrix resultM ( leftM._nRows, rightM._nCols );
Yo_Robot 5:a4014ab0a8cf 140
Yo_Robot 5:a4014ab0a8cf 141 for( int i = 0; i < resultM._nRows; i++ )
Yo_Robot 5:a4014ab0a8cf 142 for( int j = 0; j < resultM._nCols; j++ )
Yo_Robot 5:a4014ab0a8cf 143 for( int m = 0; m < rightM._nRows; m++ )
Yo_Robot 5:a4014ab0a8cf 144 resultM._matrix[i][j] += leftM._matrix[i][m] * rightM._matrix[m][j];
Yo_Robot 5:a4014ab0a8cf 145
Yo_Robot 5:a4014ab0a8cf 146 return resultM;
Yo_Robot 5:a4014ab0a8cf 147 }else{
Yo_Robot 5:a4014ab0a8cf 148 printf( "\n\nERROR:\nDiferent Dimensions @ *= operator\n" );
Yo_Robot 5:a4014ab0a8cf 149 }
Yo_Robot 5:a4014ab0a8cf 150 }
Yo_Robot 5:a4014ab0a8cf 151
Yo_Robot 5:a4014ab0a8cf 152
Yo_Robot 5:a4014ab0a8cf 153 Matrix& operator *=( Matrix& leftM, float number )
Yo_Robot 5:a4014ab0a8cf 154 {
Yo_Robot 5:a4014ab0a8cf 155 for( int i = 0; i < leftM._nRows; i++ )
Yo_Robot 5:a4014ab0a8cf 156 for( int j = 0; j < leftM._nCols; j++ )
Yo_Robot 5:a4014ab0a8cf 157 leftM._matrix[i][j] *= number;
Yo_Robot 5:a4014ab0a8cf 158
Yo_Robot 5:a4014ab0a8cf 159 return leftM;
Yo_Robot 5:a4014ab0a8cf 160 }
Yo_Robot 5:a4014ab0a8cf 161
Yo_Robot 5:a4014ab0a8cf 162
Yo_Robot 3:589fb80932b5 163 /*****************************************************************************/
Yo_Robot 3:589fb80932b5 164
Yo_Robot 3:589fb80932b5 165 // Overload operators
Yo_Robot 3:589fb80932b5 166
Yo_Robot 3:589fb80932b5 167
Yo_Robot 3:589fb80932b5 168 const Matrix operator +=( Matrix& leftM, float number )
Yo_Robot 3:589fb80932b5 169 {
Yo_Robot 3:589fb80932b5 170 for( int i = 0; i < leftM._nRows; i++ )
Yo_Robot 3:589fb80932b5 171 for( int j = 0; j < leftM._nCols; j++ )
Yo_Robot 3:589fb80932b5 172 leftM._matrix[i][j] += number;
Yo_Robot 3:589fb80932b5 173 return leftM;
Yo_Robot 3:589fb80932b5 174 }
Yo_Robot 3:589fb80932b5 175
Yo_Robot 3:589fb80932b5 176
Yo_Robot 3:589fb80932b5 177 const Matrix operator -=( Matrix& leftM, float number )
Yo_Robot 3:589fb80932b5 178 {
Yo_Robot 3:589fb80932b5 179 for( int i = 0; i < leftM._nRows; i++ )
Yo_Robot 3:589fb80932b5 180 for( int j = 0; j < leftM._nCols; j++ )
Yo_Robot 3:589fb80932b5 181 leftM._matrix[i][j] -= number;
Yo_Robot 3:589fb80932b5 182 return leftM;
Yo_Robot 3:589fb80932b5 183 }
Yo_Robot 3:589fb80932b5 184
Yo_Robot 3:589fb80932b5 185
Yo_Robot 3:589fb80932b5 186 const Matrix operator +( const Matrix& leftM, const Matrix& rightM)
Yo_Robot 3:589fb80932b5 187 {
Yo_Robot 3:589fb80932b5 188 if( leftM._nRows == rightM._nRows && leftM._nCols == rightM._nCols )
Yo_Robot 3:589fb80932b5 189 {
Yo_Robot 3:589fb80932b5 190 Matrix result( leftM._nRows, leftM._nCols );
Yo_Robot 3:589fb80932b5 191
Yo_Robot 3:589fb80932b5 192 for( int i = 0; i < leftM._nRows; i++ )
Yo_Robot 3:589fb80932b5 193 for( int j = 0; j < leftM._nCols; j++ )
Yo_Robot 3:589fb80932b5 194 result._matrix[i][j] = leftM._matrix[i][j] + rightM._matrix[i][j];
Yo_Robot 3:589fb80932b5 195
Yo_Robot 3:589fb80932b5 196 return result;
Yo_Robot 3:589fb80932b5 197
Yo_Robot 3:589fb80932b5 198 }else{
Yo_Robot 3:589fb80932b5 199 printf( "\n\nERROR\nDiferent Dimensions @ + operator \n" );
Yo_Robot 3:589fb80932b5 200 //Matrix error(4);
Yo_Robot 3:589fb80932b5 201 //error.Clear();
Yo_Robot 3:589fb80932b5 202 //return error;
Yo_Robot 3:589fb80932b5 203 }
Yo_Robot 3:589fb80932b5 204 }
Yo_Robot 3:589fb80932b5 205
Yo_Robot 3:589fb80932b5 206
Yo_Robot 3:589fb80932b5 207 const Matrix operator +( const Matrix& leftM, float number )
Yo_Robot 3:589fb80932b5 208 {
Yo_Robot 3:589fb80932b5 209 Matrix result( leftM._nRows, leftM._nCols );
Yo_Robot 3:589fb80932b5 210
Yo_Robot 3:589fb80932b5 211 for( int i = 0; i < leftM._nRows; i++ )
Yo_Robot 3:589fb80932b5 212 for( int j = 0; j < leftM._nCols; j++ )
Yo_Robot 3:589fb80932b5 213 result._matrix[i][j] = leftM._matrix[i][j] + number;
Yo_Robot 3:589fb80932b5 214
Yo_Robot 3:589fb80932b5 215 return result;
Yo_Robot 3:589fb80932b5 216 }
Yo_Robot 3:589fb80932b5 217
Yo_Robot 3:589fb80932b5 218
Yo_Robot 3:589fb80932b5 219 const Matrix operator +( float number, const Matrix& leftM )
Yo_Robot 3:589fb80932b5 220 {
Yo_Robot 3:589fb80932b5 221 return ( leftM + number );
Yo_Robot 3:589fb80932b5 222 }
Yo_Robot 3:589fb80932b5 223
Yo_Robot 3:589fb80932b5 224
Yo_Robot 3:589fb80932b5 225 const Matrix operator -( const Matrix& leftM, const Matrix& rightM )
Yo_Robot 3:589fb80932b5 226 {
Yo_Robot 3:589fb80932b5 227 if( leftM._nRows == rightM._nRows && leftM._nCols == rightM._nCols )
Yo_Robot 3:589fb80932b5 228 {
Yo_Robot 3:589fb80932b5 229 Matrix result( leftM._nRows, leftM._nCols );
Yo_Robot 3:589fb80932b5 230
Yo_Robot 3:589fb80932b5 231 for( int i = 0; i < leftM._nRows; i++ )
Yo_Robot 3:589fb80932b5 232 for( int j = 0; j < leftM._nCols; j++ )
Yo_Robot 3:589fb80932b5 233 result._matrix[i][j] = leftM._matrix[i][j] - rightM._matrix[i][j];
Yo_Robot 3:589fb80932b5 234
Yo_Robot 3:589fb80932b5 235 return result;
Yo_Robot 3:589fb80932b5 236
Yo_Robot 3:589fb80932b5 237 }else{
Yo_Robot 3:589fb80932b5 238 printf( "\n\nERROR:\nDiferent Dimensions @ + operator \n" );
Yo_Robot 3:589fb80932b5 239
Yo_Robot 3:589fb80932b5 240 }
Yo_Robot 3:589fb80932b5 241 }
Yo_Robot 3:589fb80932b5 242
Yo_Robot 3:589fb80932b5 243
Yo_Robot 3:589fb80932b5 244 const Matrix operator -( const Matrix& leftM, float number )
Yo_Robot 3:589fb80932b5 245 {
Yo_Robot 3:589fb80932b5 246 Matrix result( leftM._nRows, leftM._nCols );
Yo_Robot 3:589fb80932b5 247
Yo_Robot 3:589fb80932b5 248 for( int i = 0; i < leftM._nRows; i++ )
Yo_Robot 3:589fb80932b5 249 for( int j = 0; j < leftM._nCols; j++ )
Yo_Robot 3:589fb80932b5 250 result._matrix[i][j] = leftM._matrix[i][j] - number;
Yo_Robot 3:589fb80932b5 251
Yo_Robot 3:589fb80932b5 252 return result;
Yo_Robot 3:589fb80932b5 253 }
Yo_Robot 3:589fb80932b5 254
Yo_Robot 3:589fb80932b5 255
Yo_Robot 3:589fb80932b5 256 const Matrix operator -( float number, const Matrix& leftM )
Yo_Robot 3:589fb80932b5 257 {
Yo_Robot 3:589fb80932b5 258 return ( leftM - number );
Yo_Robot 3:589fb80932b5 259 }
Yo_Robot 3:589fb80932b5 260
Yo_Robot 3:589fb80932b5 261
Yo_Robot 3:589fb80932b5 262 const Matrix operator *( const Matrix& leftM, const Matrix& rightM )
Yo_Robot 3:589fb80932b5 263 {
Yo_Robot 3:589fb80932b5 264 if( leftM._nCols == rightM._nRows )
Yo_Robot 3:589fb80932b5 265 {
Yo_Robot 3:589fb80932b5 266 Matrix resultM ( leftM._nRows, rightM._nCols );
Yo_Robot 3:589fb80932b5 267 resultM.Clear();
Yo_Robot 3:589fb80932b5 268
Yo_Robot 3:589fb80932b5 269 for( int i = 0; i < resultM._nRows; i++ )
Yo_Robot 3:589fb80932b5 270 for( int j = 0; j < resultM._nCols; j++ )
Yo_Robot 3:589fb80932b5 271 for( int m = 0; m < rightM._nRows; m++ )
Yo_Robot 3:589fb80932b5 272 resultM._matrix[i][j] += leftM._matrix[i][m] * rightM._matrix[m][j];
Yo_Robot 3:589fb80932b5 273
Yo_Robot 3:589fb80932b5 274 return resultM;
Yo_Robot 3:589fb80932b5 275
Yo_Robot 3:589fb80932b5 276 } else {
Yo_Robot 3:589fb80932b5 277
Yo_Robot 3:589fb80932b5 278 printf("\n\nERROR:\nDiferent Dimension matrices @ * operator");
Yo_Robot 3:589fb80932b5 279 }
Yo_Robot 3:589fb80932b5 280
Yo_Robot 3:589fb80932b5 281 }
Yo_Robot 3:589fb80932b5 282
Yo_Robot 3:589fb80932b5 283
Yo_Robot 3:589fb80932b5 284 const Matrix operator *( const Matrix& leftM, float number )
Yo_Robot 3:589fb80932b5 285 {
Yo_Robot 3:589fb80932b5 286 Matrix result( leftM._nRows, leftM._nCols );
Yo_Robot 3:589fb80932b5 287
Yo_Robot 3:589fb80932b5 288 for( int i = 0; i < leftM._nRows; i++ )
Yo_Robot 3:589fb80932b5 289 for( int j = 0; j < leftM._nCols; j++ )
Yo_Robot 3:589fb80932b5 290 result._matrix[i][j] = leftM._matrix[i][j] * number;
Yo_Robot 3:589fb80932b5 291
Yo_Robot 3:589fb80932b5 292 return result;
Yo_Robot 3:589fb80932b5 293 }
Yo_Robot 3:589fb80932b5 294
Yo_Robot 3:589fb80932b5 295 const Matrix operator *( float number, const Matrix& leftM )
Yo_Robot 3:589fb80932b5 296 {
Yo_Robot 3:589fb80932b5 297 return ( leftM * number );
Yo_Robot 3:589fb80932b5 298 }
Yo_Robot 3:589fb80932b5 299
Yo_Robot 3:589fb80932b5 300
Yo_Robot 3:589fb80932b5 301 Matrix& operator <<( Matrix& leftM, float number )
Yo_Robot 3:589fb80932b5 302 {
Yo_Robot 3:589fb80932b5 303 if( leftM._pCol == leftM._nCols ) //end of Row
Yo_Robot 3:589fb80932b5 304 {
Yo_Robot 3:589fb80932b5 305 leftM._pCol = 0;
Yo_Robot 3:589fb80932b5 306 leftM._pRow++;
Yo_Robot 3:589fb80932b5 307 }
Yo_Robot 3:589fb80932b5 308 if( leftM._pRow > leftM._nRows )
Yo_Robot 3:589fb80932b5 309 {
Yo_Robot 3:589fb80932b5 310 printf( "\n\nERROR:\nAssignment out of limits @ << operator" );
Yo_Robot 3:589fb80932b5 311 return leftM;
Yo_Robot 3:589fb80932b5 312
Yo_Robot 3:589fb80932b5 313 }else{
Yo_Robot 3:589fb80932b5 314
Yo_Robot 3:589fb80932b5 315 leftM._matrix[ leftM._pRow ][ leftM._pCol ] = number;
Yo_Robot 3:589fb80932b5 316 leftM._pCol++;
Yo_Robot 3:589fb80932b5 317
Yo_Robot 3:589fb80932b5 318 return leftM;
Yo_Robot 3:589fb80932b5 319 }
Yo_Robot 3:589fb80932b5 320 }