Sh: ShLibBooleanImpl.hpp Source File

00001 // Sh: A GPU metaprogramming language.
00002 //
00003 // Copyright 2003-2005 Serious Hack Inc.
00004 // 
00005 // This software is provided 'as-is', without any express or implied
00006 // warranty. In no event will the authors be held liable for any damages
00007 // arising from the use of this software.
00008 // 
00009 // Permission is granted to anyone to use this software for any purpose,
00010 // including commercial applications, and to alter it and redistribute it
00011 // freely, subject to the following restrictions:
00012 // 
00013 // 1. The origin of this software must not be misrepresented; you must
00014 // not claim that you wrote the original software. If you use this
00015 // software in a product, an acknowledgment in the product documentation
00016 // would be appreciated but is not required.
00017 // 
00018 // 2. Altered source versions must be plainly marked as such, and must
00019 // not be misrepresented as being the original software.
00020 // 
00021 // 3. This notice may not be removed or altered from any source
00022 // distribution.
00024 #ifndef SHLIBBOOLEANIMPL_HPP
00025 #define SHLIBBOOLEANIMPL_HPP
00026 
00027 #include "ShLibBoolean.hpp"
00028 #include "ShInstructions.hpp"
00029 #include "ShAttrib.hpp"
00030 
00031 namespace SH {
00032 
00033 template<int N, typename T1, typename T2>
00034 ShGeneric<N, CT1T2> operator<(const ShGeneric<N, T1>& left, const ShGeneric<N, T2>& right)
00035 {
00036   ShAttrib<N, SH_TEMP, CT1T2> t;
00037   shSLT(t, left, right);
00038   return t;
00039 }
00040 template<int N, typename T1, typename T2>
00041 ShGeneric<N, CT1T2> operator<(const ShGeneric<N, T1>& left, const ShGeneric<1, T2>& right)
00042 {
00043   ShAttrib<N, SH_TEMP, CT1T2> t;
00044   shSLT(t, left, right);
00045   return t;
00046 }
00047 template<int N, typename T1, typename T2>
00048 ShGeneric<N, CT1T2> operator<(const ShGeneric<1, T1>& left, const ShGeneric<N, T2>& right)
00049 {
00050   ShAttrib<N, SH_TEMP, CT1T2> t;
00051   shSLT(t, left, right);
00052   return t;
00053 }
00054 template<typename T1, typename T2>
00055 ShGeneric<1, CT1T2> operator<(const ShGeneric<1, T1>& left, const ShGeneric<1, T2>& right)
00056 {
00057   ShAttrib<1, SH_TEMP, CT1T2> t;
00058   shSLT(t, left, right);
00059   return t;
00060 }
00061 SH_SHLIB_CONST_SCALAR_OP(operator<);
00062 SH_SHLIB_CONST_N_OP_BOTH(operator<);
00063 
00064 template<int N, typename T1, typename T2>
00065 ShGeneric<N, CT1T2> operator<=(const ShGeneric<N, T1>& left, const ShGeneric<N, T2>& right)
00066 {
00067   ShAttrib<N, SH_TEMP, CT1T2> t;
00068   shSLE(t, left, right);
00069   return t;
00070 }
00071 template<int N, typename T1, typename T2>
00072 ShGeneric<N, CT1T2> operator<=(const ShGeneric<N, T1>& left, const ShGeneric<1, T2>& right)
00073 {
00074   ShAttrib<N, SH_TEMP, CT1T2> t;
00075   shSLE(t, left, right);
00076   return t;
00077 }
00078 template<int N, typename T1, typename T2>
00079 ShGeneric<N, CT1T2> operator<=(const ShGeneric<1, T1>& left, const ShGeneric<N, T2>& right)
00080 {
00081   ShAttrib<N, SH_TEMP, CT1T2> t;
00082   shSLE(t, left, right);
00083   return t;
00084 }
00085 template<typename T1, typename T2>
00086 ShGeneric<1, CT1T2> operator<=(const ShGeneric<1, T1>& left, const ShGeneric<1, T2>& right)
00087 {
00088   ShAttrib<1, SH_TEMP, CT1T2> t;
00089   shSLE(t, left, right);
00090   return t;
00091 }
00092 SH_SHLIB_CONST_SCALAR_OP(operator<=);
00093 SH_SHLIB_CONST_N_OP_BOTH(operator<=);
00094 
00095 template<int N, typename T1, typename T2>
00096 ShGeneric<N, CT1T2> operator>(const ShGeneric<N, T1>& left, const ShGeneric<N, T2>& right)
00097 {
00098   ShAttrib<N, SH_TEMP, CT1T2> t;
00099   shSGT(t, left, right);
00100   return t;
00101 }
00102 template<int N, typename T1, typename T2>
00103 ShGeneric<N, CT1T2> operator>(const ShGeneric<N, T1>& left, const ShGeneric<1, T2>& right)
00104 {
00105   ShAttrib<N, SH_TEMP, CT1T2> t;
00106   shSGT(t, left, right);
00107   return t;
00108 }
00109 template<int N, typename T1, typename T2>
00110 ShGeneric<N, CT1T2> operator>(const ShGeneric<1, T1>& left, const ShGeneric<N, T2>& right)
00111 {
00112   ShAttrib<N, SH_TEMP, CT1T2> t;
00113   shSGT(t, left, right);
00114   return t;
00115 }
00116 template<typename T1, typename T2>
00117 ShGeneric<1, CT1T2> operator>(const ShGeneric<1, T1>& left, const ShGeneric<1, T2>& right)
00118 {
00119   ShAttrib<1, SH_TEMP, CT1T2> t;
00120   shSGT(t, left, right);
00121   return t;
00122 }
00123 SH_SHLIB_CONST_SCALAR_OP(operator>);
00124 SH_SHLIB_CONST_N_OP_BOTH(operator>);
00125 
00126 template<int N, typename T1, typename T2>
00127 ShGeneric<N, CT1T2> operator>=(const ShGeneric<N, T1>& left, const ShGeneric<N, T2>& right)
00128 {
00129   ShAttrib<N, SH_TEMP, CT1T2> t;
00130   shSGE(t, left, right);
00131   return t;
00132 }
00133 template<int N, typename T1, typename T2>
00134 ShGeneric<N, CT1T2> operator>=(const ShGeneric<N, T1>& left, const ShGeneric<1, T2>& right)
00135 {
00136   ShAttrib<N, SH_TEMP, CT1T2> t;
00137   shSGE(t, left, right);
00138   return t;
00139 }
00140 template<int N, typename T1, typename T2>
00141 ShGeneric<N, CT1T2> operator>=(const ShGeneric<1, T1>& left, const ShGeneric<N, T2>& right)
00142 {
00143   ShAttrib<N, SH_TEMP, CT1T2> t;
00144   shSGE(t, left, right);
00145   return t;
00146 }
00147 template<typename T1, typename T2>
00148 ShGeneric<1, CT1T2> operator>=(const ShGeneric<1, T1>& left, const ShGeneric<1, T2>& right)
00149 {
00150   ShAttrib<1, SH_TEMP, CT1T2> t;
00151   shSGE(t, left, right);
00152   return t;
00153 }
00154 SH_SHLIB_CONST_SCALAR_OP(operator>=);
00155 SH_SHLIB_CONST_N_OP_BOTH(operator>=);
00156 
00157 template<int N, typename T1, typename T2>
00158 ShGeneric<N, CT1T2> operator==(const ShGeneric<N, T1>& left, const ShGeneric<N, T2>& right)
00159 {
00160   ShAttrib<N, SH_TEMP, CT1T2> t;
00161   shSEQ(t, left, right);
00162   return t;
00163 }
00164 template<int N, typename T1, typename T2>
00165 ShGeneric<N, CT1T2> operator==(const ShGeneric<N, T1>& left, const ShGeneric<1, T2>& right)
00166 {
00167   ShAttrib<N, SH_TEMP, CT1T2> t;
00168   shSEQ(t, left, right);
00169   return t;
00170 }
00171 template<int N, typename T1, typename T2>
00172 ShGeneric<N, CT1T2> operator==(const ShGeneric<1, T1>& left, const ShGeneric<N, T2>& right)
00173 {
00174   ShAttrib<N, SH_TEMP, CT1T2> t;
00175   shSEQ(t, left, right);
00176   return t;
00177 }
00178 template<typename T1, typename T2>
00179 ShGeneric<1, CT1T2> operator==(const ShGeneric<1, T1>& left, const ShGeneric<1, T2>& right)
00180 {
00181   ShAttrib<1, SH_TEMP, CT1T2> t;
00182   shSEQ(t, left, right);
00183   return t;
00184 }
00185 SH_SHLIB_CONST_SCALAR_OP(operator==);
00186 SH_SHLIB_CONST_N_OP_BOTH(operator==);
00187 
00188 template<int N, typename T1, typename T2>
00189 ShGeneric<N, CT1T2> operator!=(const ShGeneric<N, T1>& left, const ShGeneric<N, T2>& right)
00190 {
00191   ShAttrib<N, SH_TEMP, CT1T2> t;
00192   shSNE(t, left, right);
00193   return t;
00194 }
00195 template<int N, typename T1, typename T2>
00196 ShGeneric<N, CT1T2> operator!=(const ShGeneric<N, T1>& left, const ShGeneric<1, T2>& right)
00197 {
00198   ShAttrib<N, SH_TEMP, CT1T2> t;
00199   shSNE(t, left, right);
00200   return t;
00201 }
00202 template<int N, typename T1, typename T2>
00203 ShGeneric<N, CT1T2> operator!=(const ShGeneric<1, T1>& left, const ShGeneric<N, T2>& right)
00204 {
00205   ShAttrib<N, SH_TEMP, CT1T2> t;
00206   shSNE(t, left, right);
00207   return t;
00208 }
00209 template<typename T1, typename T2>
00210 ShGeneric<1, CT1T2> operator!=(const ShGeneric<1, T1>& left, const ShGeneric<1, T2>& right)
00211 {
00212   ShAttrib<1, SH_TEMP, CT1T2> t;
00213   shSNE(t, left, right);
00214   return t;
00215 }
00216 SH_SHLIB_CONST_SCALAR_OP(operator!=);
00217 SH_SHLIB_CONST_N_OP_BOTH(operator!=);
00218 
00219 template<int N, typename T1, typename T2, typename T3>
00220 ShGeneric<N, CT1T2T3> cond(const ShGeneric<N, T1>& condition, const ShGeneric<N, T2>& left,
00221                      const ShGeneric<N, T3>& right)
00222 {
00223   ShAttrib<N, SH_TEMP, CT1T2T3> t;
00224   shCOND(t, condition, left, right);
00225   return t;
00226 }
00227 template<int N, typename T1, typename T2, typename T3>
00228 ShGeneric<N, CT1T2T3> cond(const ShGeneric<1, T1>& condition, const ShGeneric<N, T2>& left,
00229                      const ShGeneric<N, T3>& right)
00230 {
00231   ShAttrib<N, SH_TEMP, CT1T2T3> t;
00232   shCOND(t, condition, left, right);
00233   return t;
00234 }
00235 template<typename T1, typename T2, typename T3>
00236 ShGeneric<1, CT1T2T3> cond(const ShGeneric<1, T1>& condition, const ShGeneric<1, T2>& left,
00237                      const ShGeneric<1, T3>& right)
00238 {
00239   ShAttrib<1, SH_TEMP, CT1T2T3> t;
00240   shCOND(t, condition, left, right);
00241   return t;
00242 }
00243 
00244 // TODO
00245 
00246 template<int N, typename T>
00247 ShGeneric<N, T> operator!(const ShGeneric<N, T>& a)
00248 {
00249   return 1.0f - (a > 0.0f);
00250 }
00251 
00252 
00253 template<int N, typename T1, typename T2>
00254 ShGeneric<N, CT1T2> operator&&(const ShGeneric<N, T1>& a, const ShGeneric<N, T2>& b)
00255 {
00256   return min(a,b);
00257 }
00258 
00259 template<int N, typename T1, typename T2>
00260 ShGeneric<N, CT1T2> operator||(const ShGeneric<N, T1>& a, const ShGeneric<N, T2>& b)
00261 {
00262   return max(a,b);
00263 }
00264 
00265 template<int N, typename T>
00266 ShGeneric<1, T> any(const ShGeneric<N, T>& a)
00267 {
00268   ShAttrib<1, SH_TEMP, T> t = a(0);
00269   for (int i = 1; i < N; i++) {
00270     t = t || a(i);
00271   }
00272   return t;
00273 }
00274 
00275 template<int N, typename T>
00276 ShGeneric<1, T> all(const ShGeneric<N, T>& a)
00277 {
00278   ShAttrib<1, SH_TEMP, T> t = a(0);
00279   for (int i = 1; i < N; i++) {
00280     t = t && a(i);
00281   }
00282   return t;
00283 }
00284 
00285 }
00286 
00287 #endif