NEML2 2.0.0
Loading...
Searching...
No Matches
logical.h
1// Copyright 2024, UChicago Argonne, LLC
2// All Rights Reserved
3// Software Name: NEML2 -- the New Engineering material Model Library, version 2
4// By: Argonne National Laboratory
5// OPEN SOURCE LICENSE (MIT)
6//
7// Permission is hereby granted, free of charge, to any person obtaining a copy
8// of this software and associated documentation files (the "Software"), to deal
9// in the Software without restriction, including without limitation the rights
10// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11// copies of the Software, and to permit persons to whom the Software is
12// furnished to do so, subject to the following conditions:
13//
14// The above copyright notice and this permission notice shall be included in
15// all copies or substantial portions of the Software.
16//
17// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23// THE SOFTWARE.
24
25#pragma once
26
27#include <ATen/TensorOperators.h>
28
29#include "neml2/misc/types.h"
30#include "neml2/tensors/macros.h"
31#include "neml2/tensors/tensors_fwd.h"
32
33namespace neml2
34{
35// Forward declaration
36#define FORWARD_DECLARATION(T) class T
37FOR_ALL_TENSORBASE(FORWARD_DECLARATION);
38
39// Define macros (let's be responsible and undefine them afterwards)
40#define DECLARE_UNARY_OP(op, T, TR) TR op(const T & a)
41#define DECLARE_BINARY_OP(op, T1, T2, TR) TR op(const T1 & a, const T2 & b)
42#define DECLARE_BINARY_OP_SELF(op, T) DECLARE_BINARY_OP(op, T, T, T)
43#define DECLARE_BINARY_OP_SYM(op, T1, T2, TR) \
44 DECLARE_BINARY_OP(op, T1, T2, TR); \
45 DECLARE_BINARY_OP(op, T2, T1, TR)
46
48// Logical operators
50// | non-scalar-prim tensor scalar cscalar
51// ----------------------------------------------------------
52// non-scalar-prim | yes yes yes
53// tensor | yes yes yes
54// scalar | yes yes yes yes
55// cscalar | yes yes yes
56#define DECLARE_LOGICAL_SELF(T) \
57 DECLARE_BINARY_OP_SELF(operator>, T); \
58 DECLARE_BINARY_OP_SELF(operator<, T); \
59 DECLARE_BINARY_OP_SELF(operator>=, T); \
60 DECLARE_BINARY_OP_SELF(operator<=, T); \
61 DECLARE_BINARY_OP_SELF(operator&&, T); \
62 DECLARE_BINARY_OP_SELF(operator||, T); \
63 DECLARE_BINARY_OP_SELF(operator==, T); \
64 DECLARE_BINARY_OP_SELF(operator!=, T); \
65 \
66 DECLARE_BINARY_OP_SELF(gt, T); \
67 DECLARE_BINARY_OP_SELF(lt, T); \
68 DECLARE_BINARY_OP_SELF(ge, T); \
69 DECLARE_BINARY_OP_SELF(le, T); \
70 DECLARE_BINARY_OP_SELF(logical_and, T); \
71 DECLARE_BINARY_OP_SELF(logical_or, T); \
72 DECLARE_BINARY_OP_SELF(logical_xor, T); \
73 DECLARE_BINARY_OP_SELF(eq, T); \
74 DECLARE_BINARY_OP_SELF(ne, T); \
75 \
76 DECLARE_UNARY_OP(operator!, T, T); \
77 DECLARE_UNARY_OP(logical_not, T, T)
78
79#define DECLARE_LOGICAL_SCALAR(T) \
80 DECLARE_BINARY_OP_SYM(operator>, T, Scalar, T); \
81 DECLARE_BINARY_OP_SYM(operator<, T, Scalar, T); \
82 DECLARE_BINARY_OP_SYM(operator>=, T, Scalar, T); \
83 DECLARE_BINARY_OP_SYM(operator<=, T, Scalar, T); \
84 DECLARE_BINARY_OP_SYM(operator&&, T, Scalar, T); \
85 DECLARE_BINARY_OP_SYM(operator||, T, Scalar, T); \
86 DECLARE_BINARY_OP_SYM(operator==, T, Scalar, T); \
87 DECLARE_BINARY_OP_SYM(operator!=, T, Scalar, T); \
88 \
89 DECLARE_BINARY_OP_SYM(gt, T, Scalar, T); \
90 DECLARE_BINARY_OP_SYM(lt, T, Scalar, T); \
91 DECLARE_BINARY_OP_SYM(ge, T, Scalar, T); \
92 DECLARE_BINARY_OP_SYM(le, T, Scalar, T); \
93 DECLARE_BINARY_OP_SYM(logical_and, T, Scalar, T); \
94 DECLARE_BINARY_OP_SYM(logical_or, T, Scalar, T); \
95 DECLARE_BINARY_OP_SYM(logical_xor, T, Scalar, T); \
96 DECLARE_BINARY_OP_SYM(eq, T, Scalar, T); \
97 DECLARE_BINARY_OP_SYM(ne, T, Scalar, T)
98
99#define DECLARE_LOGICAL_CSCALAR(T) \
100 DECLARE_BINARY_OP_SYM(operator>, T, CScalar, T); \
101 DECLARE_BINARY_OP_SYM(operator<, T, CScalar, T); \
102 DECLARE_BINARY_OP_SYM(operator>=, T, CScalar, T); \
103 DECLARE_BINARY_OP_SYM(operator<=, T, CScalar, T); \
104 DECLARE_BINARY_OP_SYM(operator&&, T, CScalar, T); \
105 DECLARE_BINARY_OP_SYM(operator||, T, CScalar, T); \
106 DECLARE_BINARY_OP_SYM(operator==, T, CScalar, T); \
107 DECLARE_BINARY_OP_SYM(operator!=, T, CScalar, T); \
108 \
109 DECLARE_BINARY_OP_SYM(gt, T, CScalar, T); \
110 DECLARE_BINARY_OP_SYM(lt, T, CScalar, T); \
111 DECLARE_BINARY_OP_SYM(ge, T, CScalar, T); \
112 DECLARE_BINARY_OP_SYM(le, T, CScalar, T); \
113 DECLARE_BINARY_OP_SYM(logical_and, T, CScalar, T); \
114 DECLARE_BINARY_OP_SYM(logical_or, T, CScalar, T); \
115 DECLARE_BINARY_OP_SYM(logical_xor, T, CScalar, T); \
116 DECLARE_BINARY_OP_SYM(eq, T, CScalar, T); \
117 DECLARE_BINARY_OP_SYM(ne, T, CScalar, T)
118
119FOR_ALL_NONSCALAR_PRIMITIVETENSOR(DECLARE_LOGICAL_SELF);
120FOR_ALL_NONSCALAR_PRIMITIVETENSOR(DECLARE_LOGICAL_SCALAR);
121FOR_ALL_NONSCALAR_PRIMITIVETENSOR(DECLARE_LOGICAL_CSCALAR);
122DECLARE_LOGICAL_SELF(Tensor);
123DECLARE_LOGICAL_SCALAR(Tensor);
124DECLARE_LOGICAL_CSCALAR(Tensor);
125DECLARE_LOGICAL_SELF(Scalar);
126DECLARE_LOGICAL_CSCALAR(Scalar);
127
128#undef DECLARE_LOGICAL_SELF
129#undef DECLARE_LOGICAL_SCALAR
130#undef DECLARE_LOGICAL_CSCALAR
131
132// Undefine macros
133#undef DECLARE_BINARY_OP
134#undef DECLARE_BINARY_OP_SELF
135#undef DECLARE_BINARY_OP_SYM
136} // namespace neml2
neml2::Scalar
Scalar.
Definition Scalar.h:38
neml2::Tensor
Definition Tensor.h:47
neml2
Definition DiagnosticsInterface.cxx:30