SingularValueDecomposition::getU() - Code Metrics - Inspection of "Rename namespace `PHPExcel` to `PhpSpreadsheet`" - PHPOffice/PhpSpreadsheet - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( e1f81f...539a89 )

by Adrien

created 2016-08-16 14:26 UTC

SingularValueDecomposition::getU() A

↳ Parent: SingularValueDecomposition

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php

namespace PhpSpreadsheet\Shared\JAMA;

/**

 *    For an m-by-n matrix A with m >= n, the singular value decomposition is

 *    an m-by-n orthogonal matrix U, an n-by-n diagonal matrix S, and

 *    an n-by-n orthogonal matrix V so that A = U*S*V'.

 *    The singular values, sigma[$k] = S[$k][$k], are ordered so that

 *    sigma[0] >= sigma[1] >= ... >= sigma[n-1].

 *    The singular value decompostion always exists, so the constructor will

 *    never fail.  The matrix condition number and the effective numerical

 *    rank can be computed from this decomposition.

 *    @author  Paul Meagher

 *    @license PHP v3.0

 *    @version 1.1

*/

class SingularValueDecomposition

/**

     *    Internal storage of U.

     *    @var array

*/

    private $U = array();

/**

     *    Internal storage of V.

     *    @var array

*/

    private $V = array();

/**

     *    Internal storage of singular values.

     *    @var array

*/

    private $s = array();

/**

     *    Row dimension.

     *    @var int

*/

    private $m;

/**

     *    Column dimension.

     *    @var int

*/

    private $n;

/**

     *    Construct the singular value decomposition

     *    Derived from LINPACK code.

     *    @param $A Rectangular matrix

     *    @return Structure to access U, S and V.

Comprehensibility Best Practice introduced 2016-08-14 05:24 UTC by

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

*/

    public function __construct($Arg)

        // Initialize.

        $A = $Arg->getArrayCopy();

        $this->m = $Arg->getRowDimension();

        $this->n = $Arg->getColumnDimension();

        $nu      = min($this->m, $this->n);

        $e       = array();

        $work    = array();

        $wantu   = true;

        $wantv   = true;

        $nct = min($this->m - 1, $this->n);

        $nrt = max(0, min($this->n - 2, $this->m));

        // Reduce A to bidiagonal form, storing the diagonal elements

        // in s and the super-diagonal elements in e.

        for ($k = 0; $k < max($nct, $nrt); ++$k) {

            if ($k < $nct) {

                // Compute the transformation for the k-th column and

                // place the k-th diagonal in s[$k].

                // Compute 2-norm of k-th column without under/overflow.

                $this->s[$k] = 0;

                for ($i = $k; $i < $this->m; ++$i) {

                    $this->s[$k] = hypo($this->s[$k], $A[$i][$k]);

                if ($this->s[$k] != 0.0) {

                    if ($A[$k][$k] < 0.0) {

                        $this->s[$k] = -$this->s[$k];

                    for ($i = $k; $i < $this->m; ++$i) {

                        $A[$i][$k] /= $this->s[$k];

                    $A[$k][$k] += 1.0;

                $this->s[$k] = -$this->s[$k];

            for ($j = $k + 1; $j < $this->n; ++$j) {

100

                if (($k < $nct) & ($this->s[$k] != 0.0)) {

101

                    // Apply the transformation.

102

                    $t = 0;

103

                    for ($i = $k; $i < $this->m; ++$i) {

104

                        $t += $A[$i][$k] * $A[$i][$j];

105

106

                    $t = -$t / $A[$k][$k];

107

                    for ($i = $k; $i < $this->m; ++$i) {

108

                        $A[$i][$j] += $t * $A[$i][$k];

109

110

                    // Place the k-th row of A into e for the

111

                    // subsequent calculation of the row transformation.

112

                    $e[$j] = $A[$k][$j];

113

114

115

116

            if ($wantu and ($k < $nct)) {

Comprehensibility Best Practice introduced 2016-08-14 05:24 UTC by

Using logical operators such as and instead of && is generally not recommended.

PHP has two types of connecting operators (logical operators, and boolean operators):

	Logical Operators	Boolean Operator
AND - meaning	`and`	`&&`
OR - meaning	`or`	`\|\|`

The difference between these is the order in which they are executed. In most cases, you would want to use a boolean operator like &&, or ||.

Let’s take a look at a few examples:

// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);

Logical Operators are used for Control-Flow

One case where you explicitly want to use logical operators is for control-flow such as this:

$x === 5
    or die('$x must be 5.');

// Instead of
if ($x !== 5) {
    die('$x must be 5.');
}

Since die introduces problems of its own, f.e. it makes our code hardly testable, and prevents any kind of more sophisticated error handling; you probably do not want to use this in real-world code. Unfortunately, logical operators cannot be combined with throw at this point:

// The following is currently a parse error.
$x === 5
    or throw new RuntimeException('$x must be 5.');

These limitations lead to logical operators rarely being of use in current PHP code.

117

                // Place the transformation in U for subsequent back

118

                // multiplication.

119

                for ($i = $k; $i < $this->m; ++$i) {

120

                    $this->U[$i][$k] = $A[$i][$k];

121

122

123

124

            if ($k < $nrt) {

125

                // Compute the k-th row transformation and place the

126

                // k-th super-diagonal in e[$k].

127

                // Compute 2-norm without under/overflow.

128

                $e[$k] = 0;

129

                for ($i = $k + 1; $i < $this->n; ++$i) {

130

                    $e[$k] = hypo($e[$k], $e[$i]);

131

132

                if ($e[$k] != 0.0) {

133

                    if ($e[$k+1] < 0.0) {

134

                        $e[$k] = -$e[$k];

135

136

                    for ($i = $k + 1; $i < $this->n; ++$i) {

137

                        $e[$i] /= $e[$k];

138

139

                    $e[$k+1] += 1.0;

140

141

                $e[$k] = -$e[$k];

142

                if (($k+1 < $this->m) and ($e[$k] != 0.0)) {

Comprehensibility Best Practice introduced 2016-08-14 05:24 UTC by

Using logical operators such as and instead of && is generally not recommended.

PHP has two types of connecting operators (logical operators, and boolean operators):

	Logical Operators	Boolean Operator
AND - meaning	`and`	`&&`
OR - meaning	`or`	`\|\|`

The difference between these is the order in which they are executed. In most cases, you would want to use a boolean operator like &&, or ||.

Let’s take a look at a few examples:

// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);

Logical Operators are used for Control-Flow

One case where you explicitly want to use logical operators is for control-flow such as this:

$x === 5
    or die('$x must be 5.');

// Instead of
if ($x !== 5) {
    die('$x must be 5.');
}

// The following is currently a parse error.
$x === 5
    or throw new RuntimeException('$x must be 5.');

These limitations lead to logical operators rarely being of use in current PHP code.

143

                    // Apply the transformation.

144

                    for ($i = $k+1; $i < $this->m; ++$i) {

Duplication introduced 2016-08-14 05:24 UTC by

This code seems to be duplicated across your project.

145

                        $work[$i] = 0.0;

146

147

                    for ($j = $k+1; $j < $this->n; ++$j) {

148

                        for ($i = $k+1; $i < $this->m; ++$i) {

149

                            $work[$i] += $e[$j] * $A[$i][$j];

150

151

152

                    for ($j = $k + 1; $j < $this->n; ++$j) {

153

                        $t = -$e[$j] / $e[$k+1];

154

                        for ($i = $k + 1; $i < $this->m; ++$i) {

155

                            $A[$i][$j] += $t * $work[$i];

156

157

158

159

                if ($wantv) {

Duplication introduced 2016-08-14 05:24 UTC by

This code seems to be duplicated across your project.

160

                    // Place the transformation in V for subsequent

161

                    // back multiplication.

162

                    for ($i = $k + 1; $i < $this->n; ++$i) {

163

                        $this->V[$i][$k] = $e[$i];

164

165

166

167

168

169

        // Set up the final bidiagonal matrix or order p.

170

        $p = min($this->n, $this->m + 1);

171

        if ($nct < $this->n) {

172

            $this->s[$nct] = $A[$nct][$nct];

173

174

        if ($this->m < $p) {

175

            $this->s[$p-1] = 0.0;

176

177

        if ($nrt + 1 < $p) {

178

            $e[$nrt] = $A[$nrt][$p-1];

179

180

        $e[$p-1] = 0.0;

181

        // If required, generate U.

182

        if ($wantu) {

183

            for ($j = $nct; $j < $nu; ++$j) {

184

                for ($i = 0; $i < $this->m; ++$i) {

185

                    $this->U[$i][$j] = 0.0;

186

187

                $this->U[$j][$j] = 1.0;

188

189

            for ($k = $nct - 1; $k >= 0; --$k) {

190

                if ($this->s[$k] != 0.0) {

191

                    for ($j = $k + 1; $j < $nu; ++$j) {

Duplication introduced 2016-08-14 05:24 UTC by

This code seems to be duplicated across your project.

192

                        $t = 0;

193

                        for ($i = $k; $i < $this->m; ++$i) {

194

                            $t += $this->U[$i][$k] * $this->U[$i][$j];

195

196

                        $t = -$t / $this->U[$k][$k];

197

                        for ($i = $k; $i < $this->m; ++$i) {

198

                            $this->U[$i][$j] += $t * $this->U[$i][$k];

199

200

201

                    for ($i = $k; $i < $this->m; ++$i) {

202

                        $this->U[$i][$k] = -$this->U[$i][$k];

203

204

                    $this->U[$k][$k] = 1.0 + $this->U[$k][$k];

205

                    for ($i = 0; $i < $k - 1; ++$i) {

Duplication introduced 2016-08-14 05:24 UTC by

This code seems to be duplicated across your project.

206

                        $this->U[$i][$k] = 0.0;

207

208

                } else {

209

                    for ($i = 0; $i < $this->m; ++$i) {

Duplication introduced 2016-08-14 05:24 UTC by

This code seems to be duplicated across your project.

210

                        $this->U[$i][$k] = 0.0;

211

212

                    $this->U[$k][$k] = 1.0;

213

214

215

216

217

        // If required, generate V.

218

        if ($wantv) {

219

            for ($k = $this->n - 1; $k >= 0; --$k) {

220

                if (($k < $nrt) and ($e[$k] != 0.0)) {

Comprehensibility Best Practice introduced 2016-08-14 05:24 UTC by

Using logical operators such as and instead of && is generally not recommended.

PHP has two types of connecting operators (logical operators, and boolean operators):

	Logical Operators	Boolean Operator
AND - meaning	`and`	`&&`
OR - meaning	`or`	`\|\|`

The difference between these is the order in which they are executed. In most cases, you would want to use a boolean operator like &&, or ||.

Let’s take a look at a few examples:

// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);

Logical Operators are used for Control-Flow

One case where you explicitly want to use logical operators is for control-flow such as this:

$x === 5
    or die('$x must be 5.');

// Instead of
if ($x !== 5) {
    die('$x must be 5.');
}

// The following is currently a parse error.
$x === 5
    or throw new RuntimeException('$x must be 5.');

These limitations lead to logical operators rarely being of use in current PHP code.

221

                    for ($j = $k + 1; $j < $nu; ++$j) {

222

                        $t = 0;

223

                        for ($i = $k + 1; $i < $this->n; ++$i) {

224

                            $t += $this->V[$i][$k]* $this->V[$i][$j];

225

226

                        $t = -$t / $this->V[$k+1][$k];

227

                        for ($i = $k + 1; $i < $this->n; ++$i) {

228

                            $this->V[$i][$j] += $t * $this->V[$i][$k];

229

230

231

232

                for ($i = 0; $i < $this->n; ++$i) {

Duplication introduced 2016-08-14 05:24 UTC by

This code seems to be duplicated across your project.

233

                    $this->V[$i][$k] = 0.0;

234

235

                $this->V[$k][$k] = 1.0;

236

237

238

239

        // Main iteration loop for the singular values.

240

        $pp   = $p - 1;

241

        $iter = 0;

242

        $eps  = pow(2.0, -52.0);

243

244

        while ($p > 0) {

245

            // Here is where a test for too many iterations would go.

246

            // This section of the program inspects for negligible

247

            // elements in the s and e arrays.  On completion the

248

            // variables kase and k are set as follows:

249

            // kase = 1  if s(p) and e[k-1] are negligible and k<p

250

            // kase = 2  if s(k) is negligible and k<p

251

            // kase = 3  if e[k-1] is negligible, k<p, and

252

            //           s(k), ..., s(p) are not negligible (qr step).

253

            // kase = 4  if e(p-1) is negligible (convergence).

254

            for ($k = $p - 2; $k >= -1; --$k) {

255

                if ($k == -1) {

256

                    break;

257

258

                if (abs($e[$k]) <= $eps * (abs($this->s[$k]) + abs($this->s[$k+1]))) {

259

                    $e[$k] = 0.0;

260

                    break;

261

262

263

            if ($k == $p - 2) {

264

                $kase = 4;

265

            } else {

266

                for ($ks = $p - 1; $ks >= $k; --$ks) {

267

                    if ($ks == $k) {

268

                        break;

269

270

                    $t = ($ks != $p ? abs($e[$ks]) : 0.) + ($ks != $k + 1 ? abs($e[$ks-1]) : 0.);

271

                    if (abs($this->s[$ks]) <= $eps * $t) {

272

                        $this->s[$ks] = 0.0;

273

                        break;

274

275

276

                if ($ks == $k) {

277

                    $kase = 3;

278

                } elseif ($ks == $p-1) {

279

                    $kase = 1;

280

                } else {

281

                    $kase = 2;

282

                    $k = $ks;

283

284

285

            ++$k;

286

287

            // Perform the task indicated by kase.

288

            switch ($kase) {

289

                // Deflate negligible s(p).

290

                case 1:

291

                    $f = $e[$p-2];

292

                    $e[$p-2] = 0.0;

293

                    for ($j = $p - 2; $j >= $k; --$j) {

294

                        $t  = hypo($this->s[$j], $f);

295

                        $cs = $this->s[$j] / $t;

296

                        $sn = $f / $t;

297

                        $this->s[$j] = $t;

298

                        if ($j != $k) {

299

                            $f = -$sn * $e[$j-1];

300

                            $e[$j-1] = $cs * $e[$j-1];

301

302

                        if ($wantv) {

Duplication introduced 2016-08-14 05:24 UTC by

This code seems to be duplicated across your project.

303

                            for ($i = 0; $i < $this->n; ++$i) {

304

                                $t = $cs * $this->V[$i][$j] + $sn * $this->V[$i][$p-1];

305

                                $this->V[$i][$p-1] = -$sn * $this->V[$i][$j] + $cs * $this->V[$i][$p-1];

306

                                $this->V[$i][$j] = $t;

307

308

309

310

                    break;

311

                // Split at negligible s(k).

312

                case 2:

313

                    $f = $e[$k-1];

314

                    $e[$k-1] = 0.0;

315

                    for ($j = $k; $j < $p; ++$j) {

316

                        $t = hypo($this->s[$j], $f);

317

                        $cs = $this->s[$j] / $t;

318

                        $sn = $f / $t;

319

                        $this->s[$j] = $t;

320

                        $f = -$sn * $e[$j];

321

                        $e[$j] = $cs * $e[$j];

322

                        if ($wantu) {

Duplication introduced 2016-08-14 05:24 UTC by

This code seems to be duplicated across your project.

323

                            for ($i = 0; $i < $this->m; ++$i) {

324

                                $t = $cs * $this->U[$i][$j] + $sn * $this->U[$i][$k-1];

325

                                $this->U[$i][$k-1] = -$sn * $this->U[$i][$j] + $cs * $this->U[$i][$k-1];

326

                                $this->U[$i][$j] = $t;

327

328

329

330

                    break;

331

                // Perform one qr step.

332

                case 3:

333

                    // Calculate the shift.

334

                    $scale = max(max(max(max(abs($this->s[$p-1]), abs($this->s[$p-2])), abs($e[$p-2])), abs($this->s[$k])), abs($e[$k]));

335

                    $sp   = $this->s[$p-1] / $scale;

336

                    $spm1 = $this->s[$p-2] / $scale;

337

                    $epm1 = $e[$p-2] / $scale;

338

                    $sk   = $this->s[$k] / $scale;

339

                    $ek   = $e[$k] / $scale;

340

                    $b    = (($spm1 + $sp) * ($spm1 - $sp) + $epm1 * $epm1) / 2.0;

341

                    $c    = ($sp * $epm1) * ($sp * $epm1);

342

                    $shift = 0.0;

343

                    if (($b != 0.0) || ($c != 0.0)) {

344

                        $shift = sqrt($b * $b + $c);

345

                        if ($b < 0.0) {

346

                            $shift = -$shift;

347

348

                        $shift = $c / ($b + $shift);

349

350

                    $f = ($sk + $sp) * ($sk - $sp) + $shift;

351

                    $g = $sk * $ek;

352

                    // Chase zeros.

353

                    for ($j = $k; $j < $p-1; ++$j) {

354

                        $t  = hypo($f, $g);

355

                        $cs = $f/$t;

356

                        $sn = $g/$t;

357

                        if ($j != $k) {

358

                            $e[$j-1] = $t;

359

360

                        $f = $cs * $this->s[$j] + $sn * $e[$j];

361

                        $e[$j] = $cs * $e[$j] - $sn * $this->s[$j];

362

                        $g = $sn * $this->s[$j+1];

363

                        $this->s[$j+1] = $cs * $this->s[$j+1];

364

                        if ($wantv) {

Duplication introduced 2016-08-14 05:24 UTC by

This code seems to be duplicated across your project.

365

                            for ($i = 0; $i < $this->n; ++$i) {

366

                                $t = $cs * $this->V[$i][$j] + $sn * $this->V[$i][$j+1];

367

                                $this->V[$i][$j+1] = -$sn * $this->V[$i][$j] + $cs * $this->V[$i][$j+1];

368

                                $this->V[$i][$j] = $t;

369

370

371

                        $t = hypo($f, $g);

372

                        $cs = $f/$t;

373

                        $sn = $g/$t;

374

                        $this->s[$j] = $t;

375

                        $f = $cs * $e[$j] + $sn * $this->s[$j+1];

376

                        $this->s[$j+1] = -$sn * $e[$j] + $cs * $this->s[$j+1];

377

                        $g = $sn * $e[$j+1];

378

                        $e[$j+1] = $cs * $e[$j+1];

379

                        if ($wantu && ($j < $this->m - 1)) {

Duplication introduced 2016-08-14 05:24 UTC by

This code seems to be duplicated across your project.

380

                            for ($i = 0; $i < $this->m; ++$i) {

381

                                $t = $cs * $this->U[$i][$j] + $sn * $this->U[$i][$j+1];

382

                                $this->U[$i][$j+1] = -$sn * $this->U[$i][$j] + $cs * $this->U[$i][$j+1];

383

                                $this->U[$i][$j] = $t;

384

385

386

387

                    $e[$p-2] = $f;

388

                    $iter = $iter + 1;

389

                    break;

390

                // Convergence.

391

                case 4:

392

                    // Make the singular values positive.

393

                    if ($this->s[$k] <= 0.0) {

394

                        $this->s[$k] = ($this->s[$k] < 0.0 ? -$this->s[$k] : 0.0);

395

                        if ($wantv) {

Duplication introduced 2016-08-14 05:24 UTC by

This code seems to be duplicated across your project.

396

                            for ($i = 0; $i <= $pp; ++$i) {

397

                                $this->V[$i][$k] = -$this->V[$i][$k];

398

399

400

401

                    // Order the singular values.

402

                    while ($k < $pp) {

403

                        if ($this->s[$k] >= $this->s[$k+1]) {

404

                            break;

405

406

                        $t = $this->s[$k];

407

                        $this->s[$k] = $this->s[$k+1];

408

                        $this->s[$k+1] = $t;

409

                        if ($wantv and ($k < $this->n - 1)) {

Duplication introduced 2016-08-14 05:24 UTC by

This code seems to be duplicated across your project.

Comprehensibility Best Practice introduced 2016-08-14 05:24 UTC by

Using logical operators such as and instead of && is generally not recommended.

PHP has two types of connecting operators (logical operators, and boolean operators):

	Logical Operators	Boolean Operator
AND - meaning	`and`	`&&`
OR - meaning	`or`	`\|\|`

The difference between these is the order in which they are executed. In most cases, you would want to use a boolean operator like &&, or ||.

Let’s take a look at a few examples:

// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);

Logical Operators are used for Control-Flow

One case where you explicitly want to use logical operators is for control-flow such as this:

$x === 5
    or die('$x must be 5.');

// Instead of
if ($x !== 5) {
    die('$x must be 5.');
}

// The following is currently a parse error.
$x === 5
    or throw new RuntimeException('$x must be 5.');

These limitations lead to logical operators rarely being of use in current PHP code.

410

                            for ($i = 0; $i < $this->n; ++$i) {

411

                                $t = $this->V[$i][$k+1];

412

                                $this->V[$i][$k+1] = $this->V[$i][$k];

413

                                $this->V[$i][$k] = $t;

414

415

416

                        if ($wantu and ($k < $this->m-1)) {

Duplication introduced 2016-08-14 05:24 UTC by

This code seems to be duplicated across your project.

Comprehensibility Best Practice introduced 2016-08-14 05:24 UTC by

Using logical operators such as and instead of && is generally not recommended.

PHP has two types of connecting operators (logical operators, and boolean operators):

	Logical Operators	Boolean Operator
AND - meaning	`and`	`&&`
OR - meaning	`or`	`\|\|`

The difference between these is the order in which they are executed. In most cases, you would want to use a boolean operator like &&, or ||.

Let’s take a look at a few examples:

// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);

Logical Operators are used for Control-Flow

One case where you explicitly want to use logical operators is for control-flow such as this:

$x === 5
    or die('$x must be 5.');

// Instead of
if ($x !== 5) {
    die('$x must be 5.');
}

// The following is currently a parse error.
$x === 5
    or throw new RuntimeException('$x must be 5.');

These limitations lead to logical operators rarely being of use in current PHP code.

417

                            for ($i = 0; $i < $this->m; ++$i) {

418

                                $t = $this->U[$i][$k+1];

419

                                $this->U[$i][$k+1] = $this->U[$i][$k];

420

                                $this->U[$i][$k] = $t;

421

422

423

                        ++$k;

424

425

                    $iter = 0;

426

                    --$p;

427

                    break;

428

            } // end switch

429

        } // end while

430

    } // end constructor

431

432

433

/**

434

     *    Return the left singular vectors

435

436

     *    @access public

437

     *    @return U

438

*/

439

    public function getU()

440

441

        return new Matrix($this->U, $this->m, min($this->m + 1, $this->n));

442

443

444

445

/**

446

     *    Return the right singular vectors

447

448

     *    @access public

449

     *    @return V

450

*/

451

    public function getV()

452

453

        return new Matrix($this->V);

454

455

456

457

/**

458

     *    Return the one-dimensional array of singular values

459

460

     *    @access public

461

     *    @return diagonal of S.

462

*/

463

    public function getSingularValues()

464

465

        return $this->s;

466

467

468

469

/**

470

     *    Return the diagonal matrix of singular values

471

472

     *    @access public

473

     *    @return S

474

*/

475

    public function getS()

476

477

        for ($i = 0; $i < $this->n; ++$i) {

478

            for ($j = 0; $j < $this->n; ++$j) {

479

                $S[$i][$j] = 0.0;

Coding Style Comprehensibility introduced 2016-08-14 05:24 UTC by

$S was never initialized. Although not strictly required by PHP, it is generally a good practice to add $S = array(); before regardless.

480

481

            $S[$i][$i] = $this->s[$i];

Bug introduced 2016-08-14 05:24 UTC by

The variable $S does not seem to be defined for all execution paths leading up to this point.

482

483

        return new Matrix($S);

484

485

486

487

/**

488

     *    Two norm

489

490

     *    @access public

491

     *    @return max(S)

Documentation introduced 2016-08-14 05:24 UTC by

The doc-type max(S) could not be parsed: Expected "|" or "end of type", but got "(" at position 3. (view supported doc-types)

492

*/

493

    public function norm2()

494

495

        return $this->s[0];

496

497

498

499

/**

500

     *    Two norm condition number

501

502

     *    @access public

503

     *    @return max(S)/min(S)

Documentation introduced 2016-08-14 05:24 UTC by

The doc-type max(S)/min(S) could not be parsed: Expected "|" or "end of type", but got "(" at position 3. (view supported doc-types)

504

*/

505

    public function cond()

506

507

        return $this->s[0] / $this->s[min($this->m, $this->n) - 1];

508

509

510

511

/**

512

     *    Effective numerical matrix rank

513

514

     *    @access public

515

     *    @return Number of nonnegligible singular values.

516

*/

517

    public function rank()

518

519

        $eps = pow(2.0, -52.0);

520

        $tol = max($this->m, $this->n) * $this->s[0] * $eps;

521

        $r = 0;

522

        for ($i = 0; $i < count($this->s); ++$i) {

Performance Best Practice introduced 2016-08-14 05:24 UTC by

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

523

            if ($this->s[$i] > $tol) {

524

                ++$r;

525

526

527

        return $r;

528

529

530

PHPOffice / PhpSpreadsheet

Push — develop ( e1f81f...539a89 )

SingularValueDecomposition::getU() A

Complexity

Size

Duplication

Importance

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Available Fixes

Duplication Side-by-Side

Filter issues like