/elec/propeller-clock : revision 57

To get this branch, use:

bzr branch
http://bzr.ed.am/elec/propeller-clock

« back to all changes in this revision

Viewing changes to src/utility/valarray

Committer: edam
Date: 2012-02-25 01:31:43 UTC
Revision ID: tim@ed.am-20120225013143-9fet2y2d3fjlrwez

added ulibc

files added:
src/utility

src/utility/Jamfile

src/utility/Makefile

src/utility/README.md

src/utility/StandardCplusplus.h

src/utility/algorithm

src/utility/algorithm.cpp

src/utility/associative_base

src/utility/associative_base.cpp

src/utility/basic_definitions

src/utility/bitset

src/utility/bitset.cpp

src/utility/cassert

src/utility/cctype

src/utility/cerrno

src/utility/cfloat

src/utility/char_traits

src/utility/char_traits.cpp

src/utility/climits

src/utility/clocale

src/utility/cmath

src/utility/complex

src/utility/complex.cpp

src/utility/csetjmp

src/utility/csignal

src/utility/cstdarg

src/utility/cstddef

src/utility/cstdio

src/utility/cstdlib

src/utility/cstring

src/utility/ctime

src/utility/cwchar

src/utility/cwctype

src/utility/del_op.cpp

src/utility/del_opnt.cpp

src/utility/del_opv.cpp

src/utility/del_opvnt.cpp

src/utility/deque

src/utility/deque.cpp

src/utility/eh_alloc.cpp

src/utility/eh_globals.cpp

src/utility/exception

src/utility/exception.cpp

src/utility/fstream

src/utility/fstream.cpp

src/utility/func_exception

src/utility/func_exception.cpp

src/utility/functional

src/utility/iomanip

src/utility/iomanip.cpp

src/utility/ios

src/utility/ios.cpp

src/utility/iosfwd

src/utility/iostream

src/utility/iostream.cpp

src/utility/istream

src/utility/istream.cpp

src/utility/istream_helpers

src/utility/iterator

src/utility/iterator.cpp

src/utility/iterator_base

src/utility/limits

src/utility/limits.cpp

src/utility/list

src/utility/list.cpp

src/utility/locale

src/utility/locale.cpp

src/utility/map

src/utility/map.cpp

src/utility/memory

src/utility/new

src/utility/new_handler.cpp

src/utility/new_op.cpp

src/utility/new_opnt.cpp

src/utility/new_opv.cpp

src/utility/new_opvnt.cpp

src/utility/numeric

src/utility/numeric.cpp

src/utility/ostream

src/utility/ostream.cpp

src/utility/ostream_helpers

src/utility/queue

src/utility/queue.cpp

src/utility/serstream

src/utility/set

src/utility/set.cpp

src/utility/sstream

src/utility/sstream.cpp

src/utility/stack

src/utility/stack.cpp

src/utility/stdexcept

src/utility/stdexcept.cpp

src/utility/streambuf

src/utility/streambuf.cpp

src/utility/string

src/utility/string.cpp

src/utility/string_iostream

src/utility/support

src/utility/support.cpp

src/utility/system_configuration.h

src/utility/type_traits

src/utility/typeinfo

src/utility/typeinfo.cpp

src/utility/uartbuf

src/utility/unwind-cxx.h

src/utility/utility.cpp

src/utility/utility.h

src/utility/valarray

src/utility/valarray.cpp

src/utility/vector

src/utility/vector.cpp

Show diffs side-by-side

added added

removed removed

src/utility/valarray

This file is part of the uClibc++ Library.

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

#include <basic_definitions>

#ifndef __HEADER_STD_VALARRAY

#define __HEADER_STD_VALARRAY 1

#include <cstddef>

#include <cmath>

#pragma GCC visibility push(default)

namespace std{

template<class T> class valarray;

class slice;

template<class T> class slice_array;

class gslice;

template<class T> class gslice_array;

template<class T> class mask_array;

template<class T> class indirect_array;

//Actual class definitions

class _UCXXEXPORT slice {

protected:

size_t sta;

size_t siz;

size_t str;

public:

slice() : sta(0), siz(0), str(0){ }

slice(size_t a, size_t b, size_t c) : sta(a), siz(b), str(c) { }

slice(const slice& s) : sta(s.sta), siz(s.siz), str(s.str) { }

~slice() { }

size_t start() const{

return sta;

}

size_t size() const{

return siz;

}

size_t stride() const{

return str;

}

};

template<class T> class _UCXXEXPORT valarray {

friend class slice_array<T>;

protected:

T * data;

size_t length;

public:

typedef T value_type;

valarray() : data(0), length(0) { }

explicit valarray(size_t t) : data(0), length(t){

data = new T[length];

}

valarray(const T& v, size_t t) : data(0), length(t){

data = new T[length];

for(size_t i = 0; i < length; ++i){

data[i] = v;

}

valarray(const T* p, size_t t) : data(0), length(t) {

data = new T[length];

for(size_t i = 0; i < length; ++i){

data[i] = p[i];

}

valarray(const valarray& v) : data(0), length(v.length){

data = new T[length];

for(size_t i = 0; i < length; ++i){

data[i] = v.data[i];

}

100

valarray(const slice_array<T> & sa) : data(0), length(sa.s.size()){

101

data = new T[length];

102

for(unsigned int i = 0; i < length; ++i){

103

data[i] = sa.array->data[sa.s.start() + i * sa.s.stride()];

104

}

105

}

106

valarray(const gslice_array<T>&);

107

valarray(const mask_array<T>&);

108

valarray(const indirect_array<T>&);

109

~valarray(){

110

delete [] data;

111

data = 0;

112

length = 0;

113

}

114

115

valarray<T>& operator=(const valarray<T>& v){

116

for(size_t i =0; i< length; ++i){

117

data[i] = v.data[i];

118

}

119

return *this;

120

}

121

valarray<T>& operator=(const T& t){

122

for(size_t i = 0; i < length; ++i){

123

data[i] = t;

124

}

125

return *this;

126

}

127

valarray<T>& operator=(const slice_array<T>& sa){

128

for(size_t i =0; i < length; ++i){

129

data[i] = sa.data[sa.s.start() + i * sa.s.stride()];

130

}

131

return *this;

132

}

133

valarray<T>& operator=(const gslice_array<T>&);

134

valarray<T>& operator=(const mask_array<T>&);

135

valarray<T>& operator=(const indirect_array<T>&);

136

137

T operator[](size_t t) const{

138

return data[t];

139

}

140

T& operator[](size_t t){

141

return data[t];

142

}

143

144

valarray<T> operator[](slice s) const{

145

valarray<T> retval(s.size());

146

for(unsigned int i = 0; i< s.size(); ++i){

147

retval.data[i] = data[s.start() + i * s.stride()];

148

}

149

return retval;

150

}

151

152

slice_array<T> operator[](slice sl){

153

slice_array<T> retval;

154

retval.s = sl;

155

retval.array = this;

156

return retval;

157

}

158

159

valarray<T> operator[](const gslice&) const;

160

gslice_array<T> operator[](const gslice&);

161

valarray<T> operator[](const valarray<bool>&) const;

162

mask_array<T> operator[](const valarray<bool>&);

163

valarray<T> operator[](const valarray<size_t>&) const;

164

indirect_array<T> operator[](const valarray<size_t>&);

165

166

valarray<T> operator+() const{

167

valarray<T> retval(length);

168

for(size_t i = 0; i< length ; ++i){

169

retval.data[i] = +data[i];

170

}

171

return retval;

172

}

173

valarray<T> operator-() const{

174

valarray<T> retval(length);

175

for(size_t i = 0; i< length; ++i){

176

retval.data[i] = -data[i];

177

}

178

return retval;

179

}

180

valarray<T> operator~() const{

181

valarray<T> retval(length);

182

for(size_t i = 0; i< length ; ++i){

183

retval.data[i] = ~data[i];

184

}

185

return retval;

186

}

187

valarray<T> operator!() const{

188

valarray<T> retval(length);

189

for(size_t i = 0; i< length ; ++i){

190

retval.data[i] = !data[i];

191

}

192

return retval;

193

}

194

valarray<T>& operator*= (const T& t){

195

for(size_t i=0;i<length;++i){

196

data[i] *= t;

197

}

198

return *this;

199

}

200

valarray<T>& operator/= (const T& t){

201

for(size_t i=0;i<length;++i){

202

data[i] /= t;

203

}

204

return *this;

205

}

206

valarray<T>& operator%= (const T& t){

207

for(size_t i=0;i<length;++i){

208

data[i] %= t;

209

}

210

return *this;

211

}

212

valarray<T>& operator+= (const T& t){

213

for(size_t i=0;i<length;++i){

214

data[i] += t;

215

}

216

return *this;

217

}

218

valarray<T>& operator-= (const T& t){

219

for(size_t i=0;i<length;++i){

220

data[i] -= t;

221

}

222

return *this;

223

}

224

valarray<T>& operator^= (const T& t){

225

for(size_t i=0;i<length;++i){

226

data[i] ^= t;

227

}

228

return *this;

229

}

230

valarray<T>& operator&= (const T& t){

231

for(size_t i=0;i<length;++i){

232

data[i] &= t;

233

}

234

return *this;

235

}

236

valarray<T>& operator|= (const T& t){

237

for(size_t i=0;i<length; ++i){

238

data[i] != t;

239

}

240

return *this;

241

}

242

valarray<T>& operator<<=(const T& t){

243

for(size_t i=0;i<length;++i){

244

data[i] <<= t;

245

}

246

return *this;

247

}

248

valarray<T>& operator>>=(const T& t){

249

for(size_t i=0;i<length;++i){

250

data[i] >>= t;

251

}

252

return *this;

253

}

254

valarray<T>& operator*= (const valarray<T>& a){

255

for(size_t i=0;i<length;++i){

256

data[i] *= a.data[i];

257

}

258

return *this;

259

}

260

valarray<T>& operator/= (const valarray<T>& a){

261

for(size_t i=0;i<length;++i){

262

data[i] /= a.data[i];

263

}

264

return *this;

265

}

266

valarray<T>& operator%= (const valarray<T>& a){

267

for(size_t i=0;i<length;++i){

268

data[i] %= a.data[i];

269

}

270

return *this;

271

}

272

valarray<T>& operator+= (const valarray<T>& a){

273

for(size_t i=0;i<length;++i){

274

data[i] += a.data[i];

275

}

276

return *this;

277

}

278

valarray<T>& operator-= (const valarray<T>& a){

279

for(size_t i=0;i<length ;++i){

280

data[i] -= a.data[i];

281

}

282

return *this;

283

}

284

valarray<T>& operator^= (const valarray<T>& a){

285

for(size_t i=0;i<length;++i){

286

data[i] ^= a.data[i];

287

}

288

return *this;

289

}

290

valarray<T>& operator|= (const valarray<T>& a){

291

for(size_t i=0;i<length ;++i){

292

data[i] |= a.data[i];

293

}

294

return *this;

295

}

296

valarray<T>& operator&= (const valarray<T>& a){

297

for(size_t i=0;i<length;++i){

298

data[i] &= a.data[i];

299

}

300

return *this;

301

}

302

valarray<T>& operator<<=(const valarray<T>& a){

303

for(size_t i=0;i<length;++i){

304

data[i] <<= a.data[i];

305

}

306

return *this;

307

}

308

valarray<T>& operator>>=(const valarray<T>& a){

309

for(size_t i=0;i<length;++i){

310

data[i] >>= a.data[i];

311

}

312

return *this;

313

}

314

315

size_t size() const{

316

return length;

317

}

318

319

T sum() const{

320

T retval(data[0]);

321

for(size_t i = 1; i< length; ++i){

322

retval += data[i];

323

}

324

return retval;

325

}

326

327

T min() const{

328

T retval(data[0]);

329

for(size_t i = 1; i< length; ++i){

330

if(data[i] < retval){

331

retval = data[i];

332

}

333

}

334

return retval;

335

}

336

337

T max() const{

338

T retval(data[0]);

339

for(size_t i = 1; i< length; ++i){

340

if(retval < data[i]){

341

retval = data[i];

342

}

343

}

344

return retval;

345

}

346

347

valarray<T> shift (int n) const{

348

valarray<T> retval(length);

349

for(size_t i = 0; i < length ; ++i){

350

if(i + n > 0 && i + n < length){

351

retval.data[i] = data[i + n];

352

}

353

}

354

return retval;

355

}

356

valarray<T> cshift(int n) const{

357

valarray<T> retval(length);

358

for(size_t i = 0; i < length ; ++i){

359

retval.data[i] = data[ (i + n) % length ];

360

}

361

return retval;

362

}

363

valarray<T> apply(T func(T) ) const{

364

valarray<T> retval(length);

365

for(size_t i = 0; i< length; ++i){

366

retval.data[i] = func(data[i]);

367

}

368

return retval;

369

}

370

valarray<T> apply(T func(const T&)) const{

371

valarray<T> retval(length);

372

for(size_t i = 0; i< length; ++i){

373

retval.data[i] = func(data[i]);

374

}

375

return retval;

376

}

377

void resize(size_t sz, T c = T()){

378

delete [] data;

379

data = 0;

380

if(sz > 0){

381

data = new T[sz];

382

for(size_t i = 0; i < sz; ++i){

383

data[i] = c;

384

}

385

}

386

length = sz;

387

}

388

};

389

390

391

392

template <class T> class _UCXXEXPORT slice_array {

393

friend class valarray<T>;

394

public:

395

typedef T value_type;

396

397

void operator= (const valarray<T>& v) const{

398

for(unsigned int i = 0; i < s.size(); ++i){

399

array->data[s.start() + i * s.stride()] = v[i];

400

}

401

}

402

void operator= (const T & v){

403

for(unsigned int i = 0; i < s.size(); ++i){

404

array->data[s.start() + i * s.stride()] = v;

405

}

406

}

407

void fill(const T & v){

408

for(unsigned int i = 0; i < s.size(); ++i){

409

array->data[s.start() + i * s.stride()] = v;

410

}

411

}

412

void operator*= (const valarray<T>& v) const{

413

for(unsigned int i = 0; i < s.size(); ++i){

414

array->data[s.start() + i * s.stride()] *= v[i];

415

}

416

}

417

void operator/= (const valarray<T>& v) const{

418

for(unsigned int i = 0; i < s.size(); ++i){

419

array->data[s.start() + i * s.stride()] /= v[i];

420

}

421

}

422

void operator%= (const valarray<T>& v) const{

423

for(unsigned int i = 0; i < s.size(); ++i){

424

array->data[s.start() + i * s.stride()] %= v[i];

425

}

426

}

427

void operator+= (const valarray<T>& v) const{

428

for(unsigned int i = 0; i < s.size(); ++i){

429

array->data[s.start() + i * s.stride()] += v[i];

430

}

431

}

432

void operator-= (const valarray<T>& v) const{

433

for(unsigned int i = 0; i < s.size(); ++i){

434

array->data[s.start() + i * s.stride()] -= v[i];

435

}

436

}

437

void operator^= (const valarray<T>& v) const{

438

for(unsigned int i = 0; i < s.size(); ++i){

439

array->data[s.start() + i * s.stride()] ^= v[i];

440

}

441

}

442

void operator&= (const valarray<T>& v) const{

443

for(unsigned int i = 0; i < s.size(); ++i){

444

array->data[s.start() + i * s.stride()] &= v[i];

445

}

446

}

447

void operator|= (const valarray<T>& v) const{

448

for(unsigned int i = 0; i < s.size(); ++i){

449

array->data[s.start() + i * s.stride()] |= v[i];

450

}

451

}

452

void operator<<=(const valarray<T>& v) const{

453

for(unsigned int i = 0; i < s.size(); ++i){

454

array->data[s.start() + i * s.stride()] <<= v[i];

455

}

456

}

457

void operator>>=(const valarray<T>& v) const{

458

for(unsigned int i = 0; i < s.size(); ++i){

459

array->data[s.start() + i * s.stride()] >>= v[i];

460

}

461

}

462

~slice_array(){

463

array = 0;

464

}

465

466

private:

467

slice_array() : array(0){ }

468

469

public:

470

slice_array(const slice_array& sa) : array(sa.array), s(sa.s){ }

471

slice_array& operator=(const slice_array& sa){

472

array = sa.array;

473

s = sa.s;

474

}

475

476

private:

477

valarray<T> * array;

478

slice s;

479

};

480

481

482

class _UCXXEXPORT gslice {

483

private:

484

size_t sta;

485

valarray<size_t> siz;

486

valarray<size_t> str;

487

488

public:

489

gslice() : sta(0) { }

490

gslice(size_t s, const valarray<size_t>& l, const valarray<size_t>& d)

491

: sta(s), siz(l), str(d) { }

492

493

size_t start() const{

494

return sta;

495

}

496

valarray<size_t> size() const{

497

return siz;

498

}

499

valarray<size_t> stride() const{

500

return str;

501

}

502

};

503

504

template <class T> class gslice_array {

505

private:

506

friend class valarray<T>;

507

508

public:

509

~gslice_array();

510

511

void operator=(const valarray<T>& array) const;

512

void operator*=(const valarray<T>& array) const;

513

void operator/=(const valarray<T>& array) const;

514

void operator%=(const valarray<T>& array) const;

515

void operator+=(const valarray<T>& array) const;

516

void operator-=(const valarray<T>& array) const;

517

void operator^=(const valarray<T>& array) const;

518

void operator&=(const valarray<T>& array) const;

519

void operator|=(const valarray<T>& array) const;

520

void operator<<=(const valarray<T>& array) const;

521

void operator>>=(const valarray<T>& array) const;

522

523

void operator=(const T&);

524

525

private:

526

gslice_array();

527

gslice_array(const gslice_array<T>&);

528

gslice_array<T>& operator= (const gslice_array<T>& array);

529

};

530

531

532

533

template<class T> valarray<T> operator* (const valarray<T>& lhs, const valarray<T>& rhs){

534

valarray<T> retval(lhs);

535

retval *= rhs;

536

return retval;

537

}

538

539

template<class T> valarray<T> operator* (const valarray<T>& lhs, const T& rhs){

540

valarray<T> retval(lhs);

541

retval *= rhs;

542

return retval;

543

}

544

template<class T> valarray<T> operator* (const T& lhs, const valarray<T>& rhs){

545

valarray<T> retval(rhs);

546

retval *= lhs;

547

return retval;

548

}

549

template<class T> valarray<T> operator/ (const valarray<T>& lhs, const valarray<T>& rhs){

550

valarray<T> retval(lhs);

551

retval /= rhs;

552

return retval;

553

}

554

template<class T> valarray<T> operator/ (const valarray<T>& lhs, const T& rhs){

555

valarray<T> retval(lhs);

556

retval /= rhs;

557

return retval;

558

}

559

template<class T> valarray<T> operator/ (const T& lhs, const valarray<T>& rhs){

560

valarray<T> retval(lhs, rhs.size());

561

retval /= rhs;

562

return retval;

563

}

564

template<class T> valarray<T> operator% (const valarray<T>& lhs, const valarray<T>& rhs){

565

valarray<T> retval(lhs);

566

retval %= rhs;

567

return retval;

568

}

569

template<class T> valarray<T> operator% (const valarray<T>& lhs, const T& rhs){

570

valarray<T> retval(lhs);

571

retval %= rhs;

572

return retval;

573

}

574

template<class T> valarray<T> operator% (const T& lhs, const valarray<T>& rhs){

575

valarray<T> retval(lhs, rhs.size());

576

retval %= rhs;

577

return retval;

578

}

579

template<class T> valarray<T> operator+ (const valarray<T>& lhs, const valarray<T>& rhs){

580

valarray<T> retval(lhs);

581

retval += rhs;

582

return retval;

583

}

584

template<class T> valarray<T> operator+ (const valarray<T>& lhs, const T& rhs){

585

valarray<T> retval(lhs);

586

retval += rhs;

587

return retval;

588

}

589

template<class T> valarray<T> operator+ (const T& lhs, const valarray<T>& rhs){

590

valarray<T> retval(lhs, rhs.size());

591

retval += rhs;

592

return retval;

593

}

594

template<class T> valarray<T> operator- (const valarray<T>& lhs, const valarray<T>& rhs){

595

valarray<T> retval(lhs);

596

retval -= rhs;

597

return retval;

598

}

599

template<class T> valarray<T> operator- (const valarray<T>& lhs, const T& rhs){

600

valarray<T> retval(lhs);

601

retval-= rhs;

602

return retval;

603

}

604

template<class T> valarray<T> operator- (const T& lhs, const valarray<T>& rhs){

605

valarray<T> retval(lhs, rhs.size());

606

retval -= rhs;

607

return retval;

608

}

609

template<class T> valarray<T> operator^ (const valarray<T>& lhs, const valarray<T>& rhs){

610

valarray<T> retval(lhs);

611

retval ^= rhs;

612

return retval;

613

}

614

template<class T> valarray<T> operator^ (const valarray<T>& lhs, const T& rhs){

615

valarray<T> retval(lhs);

616

retval ^= rhs;

617

return retval;

618

}

619

template<class T> valarray<T> operator^ (const T& lhs, const valarray<T>& rhs){

620

valarray<T> retval(lhs, rhs.size());

621

retval ^= rhs;

622

return retval;

623

}

624

template<class T> valarray<T> operator& (const valarray<T>& lhs, const valarray<T>& rhs){

625

valarray<T> retval(lhs);

626

retval &= rhs;

627

return retval;

628

}

629

template<class T> valarray<T> operator& (const valarray<T>& lhs, const T& rhs){

630

valarray<T> retval(lhs);

631

retval &= rhs;

632

return retval;

633

}

634

template<class T> valarray<T> operator& (const T& lhs, const valarray<T>& rhs){

635

valarray<T> retval(lhs, rhs.size());

636

retval &= rhs;

637

return retval;

638

}

639

template<class T> valarray<T> operator| (const valarray<T>& lhs, const valarray<T>& rhs){

640

valarray<T> retval(lhs);

641

retval |= rhs;

642

return retval;

643

}

644

template<class T> valarray<T> operator| (const valarray<T>& lhs, const T& rhs){

645

valarray<T> retval(lhs);

646

retval |= rhs;

647

return retval;

648

}

649

template<class T> valarray<T> operator| (const T& lhs, const valarray<T>& rhs){

650

valarray<T> retval(lhs, rhs.size());

651

retval |= rhs;

652

return retval;

653

}

654

template<class T> valarray<T> operator<<(const valarray<T>& lhs, const valarray<T>& rhs){

655

valarray<T> retval(lhs);

656

retval <<= rhs;

657

return retval;

658

}

659

template<class T> valarray<T> operator<<(const valarray<T>& lhs, const T& rhs){

660

valarray<T> retval(lhs);

661

retval <<= rhs;

662

return retval;

663

}

664

template<class T> valarray<T> operator<<(const T& lhs, const valarray<T>& rhs){

665

valarray<T> retval(lhs, rhs.size());

666

retval <<= rhs;

667

return retval;

668

}

669

template<class T> valarray<T> operator>>(const valarray<T>& lhs, const valarray<T>& rhs){

670

valarray<T> retval(lhs);

671

retval >>= rhs;

672

return retval;

673

}

674

template<class T> valarray<T> operator>>(const valarray<T>& lhs, const T& rhs){

675

valarray<T> retval(lhs);

676

retval >>= rhs;

677

return retval;

678

}

679

template<class T> valarray<T> operator>>(const T& lhs, const valarray<T>& rhs){

680

valarray<T> retval(lhs, rhs.size());

681

retval >>= rhs;

682

return retval;

683

}

684

685

template<class T> valarray<bool> operator&&(const valarray<T>& lhs, const valarray<T>& rhs){

686

valarray<bool> retval(lhs.size());

687

for(size_t i = 0; i < retval.size(); ++i){

688

retval[i] = lhs[i] && rhs[i];

689

}

690

return retval;

691

}

692

template<class T> valarray<bool> operator&&(const valarray<T>& lhs, const T& rhs){

693

valarray<bool> retval(lhs.size());

694

for(size_t i = 0; i <retval.size(); ++i){

695

retval[i] = lhs[i] && rhs;

696

}

697

return retval;

698

}

699

template<class T> valarray<bool> operator&&(const T& lhs, const valarray<T>& rhs){

700

valarray<bool> retval(rhs.size());

701

for(size_t i = 0; i <retval.size(); ++i){

702

retval[i] = lhs && rhs[i];

703

}

704

return retval;

705

}

706

template<class T> valarray<bool> operator||(const valarray<T>&lhs, const valarray<T>& rhs){

707

valarray<bool> retval(lhs.size());

708

for(size_t i = 0; i <retval.size(); ++i){

709

retval[i] = lhs[i] || rhs[i];

710

}

711

return retval;

712

}

713

template<class T> valarray<bool> operator||(const valarray<T>& lhs, const T& rhs){

714

valarray<bool> retval(lhs.size());

715

for(size_t i = 0; i <retval.size(); ++i){

716

retval[i] = lhs[i] || rhs;

717

}

718

return retval;

719

}

720

template<class T> valarray<bool> operator||(const T& lhs, const valarray<T>& rhs){

721

valarray<bool> retval(rhs.size());

722

for(size_t i = 0; i < retval.size(); ++i){

723

retval[i] = lhs || rhs[i];

724

}

725

return retval;

726

}

727

728

template<class T> valarray<bool> operator==(const valarray<T>& lhs, const valarray<T>& rhs){

729

valarray<bool> retval(lhs.size());

730

for(size_t i = 0; i <retval.size(); ++i){

731

retval[i] = lhs[i] == rhs[i];

732

}

733

return retval;

734

}

735

template<class T> valarray<bool> operator==(const valarray<T>& lhs, const T& rhs){

736

valarray<bool> retval(lhs.size());

737

for(size_t i = 0; i < retval.size(); ++i){

738

retval[i] = lhs[i] == rhs;

739

}

740

return retval;

741

}

742

template<class T> valarray<bool> operator==(const T& lhs, const valarray<T>& rhs){

743

valarray<bool> retval(rhs.size());

744

for(size_t i = 0; i < retval.size(); ++i){

745

retval[i] = lhs == rhs[i];

746

}

747

return retval;

748

}

749

template<class T> valarray<bool> operator!=(const valarray<T>& lhs, const valarray<T>& rhs){

750

valarray<bool> retval(lhs.size());

751

for(size_t i = 0; i <retval.size(); ++i){

752

retval[i] = lhs[i] != rhs[i];

753

}

754

return retval;

755

}

756

template<class T> valarray<bool> operator!=(const valarray<T>& lhs, const T& rhs){

757

valarray<bool> retval(lhs.size());

758

for(size_t i = 0; i <retval.size(); ++i){

759

retval[i] = lhs[i] != rhs;

760

}

761

return retval;

762

}

763

template<class T> valarray<bool> operator!=(const T& lhs, const valarray<T>& rhs){

764

valarray<bool> retval(rhs.size());

765

for(size_t i = 0; i <retval.size(); ++i){

766

retval[i] = lhs != rhs[i];

767

}

768

return retval;

769

}

770

template<class T> valarray<bool> operator< (const valarray<T>& lhs, const valarray<T>& rhs){

771

valarray<bool> retval(lhs.size());

772

for(size_t i = 0; i <retval.size(); ++i){

773

retval[i] = lhs[i] < rhs[i];

774

}

775

return retval;

776

}

777

template<class T> valarray<bool> operator< (const valarray<T>& lhs, const T& rhs){

778

valarray<bool> retval(lhs.size());

779

for(size_t i = 0; i <retval.size(); ++i){

780

retval[i] = lhs[i] < rhs;

781

}

782

return retval;

783

}

784

template<class T> valarray<bool> operator< (const T& lhs, const valarray<T>& rhs){

785

valarray<bool> retval(rhs.size());

786

for(size_t i = 0; i <retval.size(); ++i){

787

retval[i] = lhs < rhs[i];

788

}

789

return retval;

790

}

791

template<class T> valarray<bool> operator> (const valarray<T>& lhs, const valarray<T>& rhs){

792

valarray<bool> retval(lhs.size());

793

for(size_t i = 0; i <retval.size(); ++i){

794

retval[i] = lhs[i] > rhs[i];

795

}

796

return retval;

797

}

798

template<class T> valarray<bool> operator> (const valarray<T>& lhs, const T& rhs){

799

valarray<bool> retval(lhs.size());

800

for(size_t i = 0; i <retval.size(); ++i){

801

retval[i] = lhs[i] > rhs;

802

}

803

return retval;

804

}

805

template<class T> valarray<bool> operator> (const T& rhs, const valarray<T>& lhs){

806

valarray<bool> retval(rhs.size());

807

for(size_t i = 0; i <retval.size(); ++i){

808

retval[i] = lhs > rhs[i];

809

}

810

return retval;

811

}

812

template<class T> valarray<bool> operator<=(const valarray<T>& lhs, const valarray<T>& rhs){

813

valarray<bool> retval(lhs.size());

814

for(size_t i = 0; i <retval.size(); ++i){

815

retval[i] = lhs[i] <= rhs[i];

816

}

817

return retval;

818

}

819

template<class T> valarray<bool> operator<=(const valarray<T>& lhs, const T& rhs){

820

valarray<bool> retval(lhs.size());

821

for(size_t i = 0; i <retval.size(); ++i){

822

retval[i] = lhs[i] <= rhs;

823

}

824

return retval;

825

}

826

template<class T> valarray<bool> operator<=(const T& lhs, const valarray<T>& rhs){

827

valarray<bool> retval(rhs.size());

828

for(size_t i = 0; i <retval.size(); ++i){

829

retval[i] = lhs <= rhs[i];

830

}

831

return retval;

832

}

833

template<class T> valarray<bool> operator>=(const valarray<T>& lhs, const valarray<T>& rhs){

834

valarray<bool> retval(lhs.size());

835

for(size_t i = 0; i <retval.size(); ++i){

836

retval[i] = lhs[i] >= rhs[i];

837

}

838

return retval;

839

}

840

template<class T> valarray<bool> operator>=(const valarray<T>& lhs, const T& rhs){

841

valarray<bool> retval(lhs.size());

842

for(size_t i = 0; i <retval.size(); ++i){

843

retval[i] = lhs[i] >= rhs;

844

}

845

return retval;

846

}

847

template<class T> valarray<bool> operator>=(const T& lhs, const valarray<T>& rhs){

848

valarray<bool> retval(rhs.size());

849

for(size_t i = 0; i <retval.size(); ++i){

850

retval[i] = lhs >= rhs[i];

851

}

852

return retval;

853

}

854

template<class T> T min(const valarray<T>& x){

855

T retval(x[0]);

856

for(size_t i = 1; i < x.size(); ++i){

857

if(x[i] < retval){

858

retval = x[i];

859

}

860

}

861

}

862

template<class T> T max(const valarray<T>& x){

863

T retval(x[0]);

864

for(size_t i = 1; i < x.size(); ++i){

865

if(x[i] > retval){

866

retval = x[i];

867

}

868

}

869

}

870

871

template<class T> valarray<T> abs (const valarray<T>& x){

872

valarray<T> retval(x.size());

873

for(size_t i = 0; i < retval.size(); ++i){

874

retval[i] = abs(x[i]);

875

}

876

}

877

template<class T> valarray<T> acos (const valarray<T>& x){

878

valarray<T> retval(x.size());

879

for(size_t i = 0; i < retval.size(); ++i){

880

retval[i] = acos(x[i]);

881

}

882

}

883

template<class T> valarray<T> asin (const valarray<T>& x){

884

valarray<T> retval(x.size());

885

for(size_t i = 0; i < retval.size(); ++i){

886

retval[i] = asin(x[i]);

887

}

888

}

889

template<class T> valarray<T> atan (const valarray<T>& x){

890

valarray<T> retval(x.size());

891

for(size_t i = 0; i < retval.size(); ++i){

892

retval[i] = atan(x[i]);

893

}

894

}

895

template<class T> valarray<T> atan2(const valarray<T>& y, const valarray<T>& x){

896

valarray<T> retval(y.size());

897

for(size_t i = 0; i < retval.size(); ++i){

898

retval[i] = atan2(y[i], x[i]);

899

}

900

}

901

template<class T> valarray<T> atan2(const valarray<T>& y, const T& x){

902

valarray<T> retval(y.size());

903

for(size_t i = 0; i < retval.size(); ++i){

904

retval[i] = atan2(y[i], x);

905

}

906

}

907

template<class T> valarray<T> atan2(const T& y, const valarray<T>& x){

908

valarray<T> retval(x.size());

909

for(size_t i = 0; i < retval.size(); ++i){

910

retval[i] = abs(y, x[i]);

911

}

912

}

913

template<class T> valarray<T> cos (const valarray<T>& x){

914

valarray<T> retval(x.size());

915

for(size_t i = 0; i < retval.size(); ++i){

916

retval[i] = cos(x[i]);

917

}

918

}

919

template<class T> valarray<T> cosh (const valarray<T>& x){

920

valarray<T> retval(x.size());

921

for(size_t i = 0; i < retval.size(); ++i){

922

retval[i] = cosh(x[i]);

923

}

924

}

925

template<class T> valarray<T> exp (const valarray<T>& x){

926

valarray<T> retval(x.size());

927

for(size_t i = 0; i < retval.size(); ++i){

928

retval[i] = exp(x[i]);

929

}

930

}

931

template<class T> valarray<T> log (const valarray<T>& x){

932

valarray<T> retval(x.size());

933

for(size_t i = 0; i < retval.size(); ++i){

934

retval[i] = log(x[i]);

935

}

936

}

937

template<class T> valarray<T> log10(const valarray<T>& x){

938

valarray<T> retval(x.size());

939

for(size_t i = 0; i < retval.size(); ++i){

940

retval[i] = log10(x[i]);

941

}

942

}

943

template<class T> valarray<T> pow (const valarray<T>& x, const valarray<T>& y){

944

valarray<T> retval(x.size());

945

for(size_t i = 0; i < retval.size(); ++i){

946

retval[i] = pow(x[i], y[i]);

947

}

948

}

949

template<class T> valarray<T> pow (const valarray<T>& x, const T& y){

950

valarray<T> retval(x.size());

951

for(size_t i = 0; i < retval.size(); ++i){

952

retval[i] = pow(x[i], y);

953

}

954

}

955

template<class T> valarray<T> pow (const T& x, const valarray<T>& y){

956

valarray<T> retval(x.size());

957

for(size_t i = 0; i < retval.size(); ++i){

958

retval[i] = pow(x, y[i]);

959

}

960

}

961

template<class T> valarray<T> sin (const valarray<T>& x){

962

valarray<T> retval(x.size());

963

for(size_t i = 0; i < retval.size(); ++i){

964

retval[i] = sin(x[i]);

965

}

966

}

967

template<class T> valarray<T> sinh (const valarray<T>& x){

968

valarray<T> retval(x.size());

969

for(size_t i = 0; i < retval.size(); ++i){

970

retval[i] = sinh(x[i]);

971

}

972

}

973

template<class T> valarray<T> sqrt (const valarray<T>& x){

974

valarray<T> retval(x.size());

975

for(size_t i = 0; i < retval.size(); ++i){

976

retval[i] = sqrt(x[i]);

977

}

978

}

979

template<class T> valarray<T> tan (const valarray<T>& x){

980

valarray<T> retval(x.size());

981

for(size_t i = 0; i < retval.size(); ++i){

982

retval[i] = tan(x[i]);

983

}

984

}

985

template<class T> valarray<T> tanh (const valarray<T>& x){

986

valarray<T> retval(x.size());

987

for(size_t i = 0; i < retval.size(); ++i){

988

retval[i] = tanh(x[i]);

989

}

990

}

991

992

}

993

994

#pragma GCC visibility pop

995

996

#endif