RootsI.H
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | www.openfoam.com
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8  Copyright (C) 2017 OpenFOAM Foundation
9 -------------------------------------------------------------------------------
10 License
11  This file is part of OpenFOAM.
12 
13  OpenFOAM is free software: you can redistribute it and/or modify it
14  under the terms of the GNU General Public License as published by
15  the Free Software Foundation, either version 3 of the License, or
16  (at your option) any later version.
17 
18  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
19  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
20  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21  for more details.
22 
23  You should have received a copy of the GNU General Public License
24  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
25 
26 \*---------------------------------------------------------------------------*/
27 
28 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
29 
30 template <Foam::direction N>
31 inline Foam::Roots<N>::Roots()
32 :
33  types_(0)
34 {
35  forAll(*this, i)
36  {
37  type(i, roots::nan);
38  }
39 }
40 
41 
42 template <Foam::direction N>
43 inline Foam::Roots<N>::Roots(const roots::type t, const scalar x)
44 :
45  types_(0)
46 {
47  forAll(*this, i)
48  {
49  this->v_[i] = x;
50  type(i, t);
51  }
52 }
53 
54 
55 template <Foam::direction N>
56 inline Foam::Roots<N>::Roots
57 (
58  const roots::type t,
59  const scalar x,
60  const Roots<N - 1>& xs
61 )
62 :
63  types_(0)
64 {
65  this->v_[0] = x;
66  type(0, t);
67  forAll(xs, i)
68  {
69  this->v_[i+1] = xs[i];
70  type(i + 1, xs.type(i));
71  }
72 }
73 
74 
75 template <Foam::direction N>
76 inline Foam::Roots<N>::Roots
77 (
78  const Roots<N - 1>& xs,
79  const roots::type t,
80  const scalar x
81 )
82 :
83  types_(0)
84 {
85  forAll(xs, i)
86  {
87  this->v_[i] = xs[i];
88  type(i, xs.type(i));
89  }
90  this->v_[N-1] = x;
91  type(N - 1, t);
92 }
93 
94 
95 template <Foam::direction N>
96 template <Foam::direction M>
97 inline Foam::Roots<N>::Roots
98 (
99  const Roots<M>& xs,
100  const Roots<N - M>& ys
101 )
102 :
103  types_(0)
104 {
105  forAll(xs, i)
106  {
107  this->v_[i] = xs[i];
108  type(i, xs.type(i));
109  }
110  forAll(ys, i)
111  {
112  this->v_[i + M] = ys[i];
113  type(i + M, ys.type(i));
114  }
115 }
116 
117 
118 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
119 
120 template <Foam::direction N>
121 inline void Foam::Roots<N>::type
122 (
123  const direction i,
124  const roots::type t
125 )
126 {
127  types_ += (t - type(i)) << 3*i;
128 }
129 
130 
131 template <Foam::direction N>
132 inline Foam::roots::type Foam::Roots<N>::type(const direction i) const
133 {
134  return static_cast<roots::type>((types_ >> 3*i) & 7);
135 }
136 
137 
138 // ************************************************************************* //
Foam::Roots::type
void type(const direction i, const roots::type t)
Set the type of the i-th root.
Definition: RootsI.H:122
Foam::roots::nan
Definition: Roots.H:60
Foam::Roots::Roots
Roots()
Construct null.
Definition: RootsI.H:31
Foam::VectorSpace< Roots< N >, scalar, N >::v_
scalar v_[Ncmpts]
The components of this vector space.
Definition: VectorSpace.H:83
forAll
#define forAll(list, i)
Loop across all elements in list.
Definition: stdFoam.H:296
Foam::type
fileName::Type type(const fileName &name, const bool followLink=true)
Return the file type: DIRECTORY or FILE, normally following symbolic links.
Definition: MSwindows.C:590
M
#define M(I)
Foam::direction
uint8_t direction
Definition: direction.H:52
x
x
Definition: LISASMDCalcMethod2.H:52
Foam::roots::type
type
Types of root.
Definition: Roots.H:54
N
const Vector< label > N(dict.get< Vector< label >>("N"))
Foam::Roots
Templated storage for the roots of polynomial equations, plus flags to indicate the nature of the roo...
Definition: Roots.H:70