Loading...
Searching...
No Matches
Public Member Functions | Private Member Functions | Private Attributes
SymEngine::Assumptions Class Reference
+ Collaboration diagram for SymEngine::Assumptions:

Public Member Functions

 Assumptions (const set_basic &statements)
 
tribool is_complex (const RCP< const Basic > &symbol) const
 
tribool is_real (const RCP< const Basic > &symbol) const
 
tribool is_rational (const RCP< const Basic > &symbol) const
 
tribool is_integer (const RCP< const Basic > &symbol) const
 
tribool is_positive (const RCP< const Basic > &symbol) const
 
tribool is_nonnegative (const RCP< const Basic > &symbol) const
 
tribool is_negative (const RCP< const Basic > &symbol) const
 
tribool is_nonpositive (const RCP< const Basic > &symbol) const
 
tribool is_nonzero (const RCP< const Basic > &symbol) const
 
tribool is_zero (const RCP< const Basic > &symbol) const
 

Private Member Functions

void set_map (umap_basic_bool &map, const RCP< const Basic > &symbol, bool value)
 
tribool from_map (const umap_basic_bool &map, const RCP< const Basic > &symbol) const
 

Private Attributes

set_basic complex_symbols_
 
set_basic real_symbols_
 
set_basic rational_symbols_
 
set_basic integer_symbols_
 
umap_basic_bool positive_
 
umap_basic_bool nonnegative_
 
umap_basic_bool negative_
 
umap_basic_bool nonpositive_
 
umap_basic_bool nonzero_
 
umap_basic_bool zero_
 

Detailed Description

Definition at line 13 of file assumptions.h.

Constructor & Destructor Documentation

◆ Assumptions()

SymEngine::Assumptions::Assumptions ( const set_basic &  statements)

Definition at line 8 of file assumptions.cpp.

9{
10 // Convert a set of statements into a faster and easier internal form
11 for (const auto &s : statements) {
12 if (is_a<Contains>(*s)) {
13 const Contains &contains = down_cast<const Contains &>(*s);
14 const auto expr = contains.get_expr();
15 const auto set = contains.get_set();
16 if (is_a<Symbol>(*expr)) {
17 if (is_a<Complexes>(*set)) {
18 complex_symbols_.insert(expr);
19 } else if (is_a<Reals>(*set)) {
20 complex_symbols_.insert(expr);
21 real_symbols_.insert(expr);
22 } else if (is_a<Rationals>(*set)) {
23 complex_symbols_.insert(expr);
24 real_symbols_.insert(expr);
25 rational_symbols_.insert(expr);
26 } else if (is_a<Integers>(*set)) {
27 complex_symbols_.insert(expr);
28 real_symbols_.insert(expr);
29 rational_symbols_.insert(expr);
30 integer_symbols_.insert(expr);
31 }
32 }
33 } else if (is_a<LessThan>(*s)) {
34 const LessThan &less_than = down_cast<const LessThan &>(*s);
35 const auto &arg1 = less_than.get_arg1();
36 const auto &arg2 = less_than.get_arg2();
37 if (is_a<Symbol>(*arg2) and is_a_Number(*arg1)) {
38 real_symbols_.insert(arg2);
39 if (down_cast<const Number &>(*arg1).is_positive()) {
40 set_map(nonnegative_, arg2, true);
41 set_map(positive_, arg2, true);
42 set_map(negative_, arg2, false);
43 set_map(nonpositive_, arg2, false);
44 set_map(nonzero_, arg2, true);
45 set_map(zero_, arg2, false);
46 } else if (down_cast<const Number &>(*arg1).is_zero()) {
47 set_map(nonnegative_, arg2, true);
48 set_map(negative_, arg2, false);
49 }
50 } else if (is_a<Symbol>(*arg1) and is_a_Number(*arg2)) {
51 real_symbols_.insert(arg1);
52 if (down_cast<const Number &>(*arg2).is_negative()) {
53 set_map(nonnegative_, arg1, false);
54 set_map(positive_, arg1, false);
55 set_map(negative_, arg1, true);
56 set_map(nonpositive_, arg1, true);
57 set_map(nonzero_, arg1, true);
58 set_map(zero_, arg1, false);
59 } else if (down_cast<const Number &>(*arg2).is_zero()) {
60 set_map(nonpositive_, arg1, true);
61 set_map(positive_, arg1, false);
62 }
63 }
64 } else if (is_a<StrictLessThan>(*s)) {
65 const StrictLessThan &strictly_less_than
66 = down_cast<const StrictLessThan &>(*s);
67 const auto arg1 = strictly_less_than.get_arg1();
68 const auto arg2 = strictly_less_than.get_arg2();
69 if (is_a<Symbol>(*arg2) and is_a_Number(*arg1)) {
70 real_symbols_.insert(arg2);
71 if (not down_cast<const Number &>(*arg1).is_negative()) {
72 set_map(nonnegative_, arg2, true);
73 set_map(positive_, arg2, true);
74 set_map(negative_, arg2, false);
75 set_map(nonpositive_, arg2, false);
76 set_map(nonzero_, arg2, true);
77 set_map(zero_, arg2, false);
78 }
79 } else if (is_a<Symbol>(*arg1) and is_a_Number(*arg2)) {
80 real_symbols_.insert(arg1);
81 if (not down_cast<const Number &>(*arg2).is_positive()) {
82 set_map(nonnegative_, arg1, false);
83 set_map(positive_, arg1, false);
84 set_map(negative_, arg1, true);
85 set_map(nonpositive_, arg1, true);
86 set_map(nonzero_, arg1, true);
87 set_map(zero_, arg1, false);
88 }
89 }
90 } else if (is_a<Equality>(*s)) {
91 const Equality &equals = down_cast<const Equality &>(*s);
92 const auto arg1 = equals.get_arg1();
93 const auto arg2 = equals.get_arg2();
94 if (is_a_Number(*arg1) and is_a<Symbol>(*arg2)) {
95 complex_symbols_.insert(arg2);
96 if (down_cast<const Number &>(*arg1).is_zero()) {
97 set_map(zero_, arg2, true);
98 real_symbols_.insert(arg2);
99 rational_symbols_.insert(arg2);
100 integer_symbols_.insert(arg2);
101 set_map(positive_, arg2, false);
102 set_map(negative_, arg2, false);
103 set_map(nonpositive_, arg2, true);
104 set_map(nonnegative_, arg2, true);
105 set_map(nonzero_, arg2, false);
106 } else {
107 set_map(zero_, arg2, false);
108 set_map(nonzero_, arg2, true);
109 }
110 }
111 } else if (is_a<Unequality>(*s)) {
112 const Unequality &uneq = down_cast<const Unequality &>(*s);
113 const auto arg1 = uneq.get_arg1();
114 const auto arg2 = uneq.get_arg2();
115 if (is_a_Number(*arg1) and is_a<Symbol>(*arg2)) {
116 if (down_cast<const Number &>(*arg1).is_zero()) {
117 set_map(zero_, arg2, false);
118 set_map(nonzero_, arg2, true);
119 }
120 }
121 }
122 }
123}
std::set::insert
T insert(T... args)
SymEngine::is_a_Number
bool is_a_Number(const Basic &b)
Definition: number.h:130

Member Function Documentation

◆ from_map()

tribool SymEngine::Assumptions::from_map ( const umap_basic_bool &  map,
const RCP< const Basic > &  symbol 
) const
private

Definition at line 137 of file assumptions.cpp.

139{
140 auto it = map.find(symbol);
141 if (it != map.end()) {
142 return (tribool)((*it).second);
143 } else {
144 return tribool::indeterminate;
145 }
146}
SymEngine::symbol
RCP< const Symbol > symbol(const std::string &name)
inline version to return Symbol
Definition: symbol.h:82

◆ is_complex()

tribool SymEngine::Assumptions::is_complex ( const RCP< const Basic > &  symbol) const

Definition at line 148 of file assumptions.cpp.

149{
150 bool cmplx = complex_symbols_.find(symbol) != complex_symbols_.end();
151 return cmplx ? tribool::tritrue : tribool::indeterminate;
152}
std::set::end
T end(T... args)
std::set::find
T find(T... args)

◆ is_integer()

tribool SymEngine::Assumptions::is_integer ( const RCP< const Basic > &  symbol) const

Definition at line 166 of file assumptions.cpp.

167{
168 bool integer = integer_symbols_.find(symbol) != integer_symbols_.end();
169 return integer ? tribool::tritrue : tribool::indeterminate;
170}
SymEngine::integer
std::enable_if< std::is_integral< T >::value, RCP< constInteger > >::type integer(T i)
Definition: integer.h:197

◆ is_negative()

tribool SymEngine::Assumptions::is_negative ( const RCP< const Basic > &  symbol) const

Definition at line 182 of file assumptions.cpp.

183{
184 return from_map(negative_, symbol);
185}

◆ is_nonnegative()

tribool SymEngine::Assumptions::is_nonnegative ( const RCP< const Basic > &  symbol) const

Definition at line 177 of file assumptions.cpp.

178{
179 return from_map(nonnegative_, symbol);
180}

◆ is_nonpositive()

tribool SymEngine::Assumptions::is_nonpositive ( const RCP< const Basic > &  symbol) const

Definition at line 187 of file assumptions.cpp.

188{
189 return from_map(nonpositive_, symbol);
190}

◆ is_nonzero()

tribool SymEngine::Assumptions::is_nonzero ( const RCP< const Basic > &  symbol) const

Definition at line 192 of file assumptions.cpp.

193{
194 return from_map(nonzero_, symbol);
195}

◆ is_positive()

tribool SymEngine::Assumptions::is_positive ( const RCP< const Basic > &  symbol) const

Definition at line 172 of file assumptions.cpp.

173{
174 return from_map(positive_, symbol);
175}

◆ is_rational()

tribool SymEngine::Assumptions::is_rational ( const RCP< const Basic > &  symbol) const

Definition at line 160 of file assumptions.cpp.

161{
162 bool rational = rational_symbols_.find(symbol) != rational_symbols_.end();
163 return rational ? tribool::tritrue : tribool::indeterminate;
164}
SymEngine::rational
RCP< const Number > rational(long n, long d)
convenience creator from two longs
Definition: rational.h:328

◆ is_real()

tribool SymEngine::Assumptions::is_real ( const RCP< const Basic > &  symbol) const

Definition at line 154 of file assumptions.cpp.

155{
156 bool real = real_symbols_.find(symbol) != real_symbols_.end();
157 return real ? tribool::tritrue : tribool::indeterminate;
158}

◆ is_zero()

tribool SymEngine::Assumptions::is_zero ( const RCP< const Basic > &  symbol) const

Definition at line 197 of file assumptions.cpp.

198{
199 return from_map(zero_, symbol);
200}

◆ set_map()

void SymEngine::Assumptions::set_map ( umap_basic_bool &  map,
const RCP< const Basic > &  symbol,
bool  value 
)
private

Definition at line 125 of file assumptions.cpp.

127{
128 // Set element in map to true or false. Check for consistency within map
129 tribool old_value = from_map(map, symbol);
130 if ((is_true(old_value) and not value) or (is_false(old_value) and value)) {
131 throw SymEngineException("Symbol " + symbol->__str__()
132 + " have inconsistent positive/negativeness");
133 }
134 map[symbol] = value;
135}

Field Documentation

◆ complex_symbols_

set_basic SymEngine::Assumptions::complex_symbols_
private

Definition at line 16 of file assumptions.h.

◆ integer_symbols_

set_basic SymEngine::Assumptions::integer_symbols_
private

Definition at line 19 of file assumptions.h.

◆ negative_

umap_basic_bool SymEngine::Assumptions::negative_
private

Definition at line 22 of file assumptions.h.

◆ nonnegative_

umap_basic_bool SymEngine::Assumptions::nonnegative_
private

Definition at line 21 of file assumptions.h.

◆ nonpositive_

umap_basic_bool SymEngine::Assumptions::nonpositive_
private

Definition at line 23 of file assumptions.h.

◆ nonzero_

umap_basic_bool SymEngine::Assumptions::nonzero_
private

Definition at line 24 of file assumptions.h.

◆ positive_

umap_basic_bool SymEngine::Assumptions::positive_
private

Definition at line 20 of file assumptions.h.

◆ rational_symbols_

set_basic SymEngine::Assumptions::rational_symbols_
private

Definition at line 18 of file assumptions.h.

◆ real_symbols_

set_basic SymEngine::Assumptions::real_symbols_
private

Definition at line 17 of file assumptions.h.

◆ zero_

umap_basic_bool SymEngine::Assumptions::zero_
private

Definition at line 25 of file assumptions.h.

The documentation for this class was generated from the following files:
Generated by Doxygen 1.9.6 and the doxyYoda theme