//should be optimized
const complex_matrix_type make_new_a() const
{
auto A = make_a();
auto gs = make_gscale();
auto gy = make_gyvec();
auto const gd = make_gd(make_beam_vector());
auto const Gm = make_gm(gd);
auto gm = make_unique_beams(Gm);
array_type gxu = scale_multiply( gx, gs );
array_type gyu = scale_multiply( gy, gs );
array_type gu = array_type( gxu.norm(), gyu.norm(), 0 );
array_vector_type gxy( gd );
std::for_each( gxy.begin(), gxy.end(), [gu](array_type& a){ a[0]*=gu[1]; a[1]*=gu[0]; a[2]=0; } );
vector_type gxy2( gxy.size() );
feng::for_each( gxy2.begin(), gxy2.end(), gxy.begin(), [](value_type& v, const array_type& a){ v = a.norm(); v*=v; } );
feng::for_each( A.diag_begin(), A.diag_end(), gxy2.begin(), [](complex_type& c, const value_type& v){ c = complex_type(-v, 0); } );
std::cout << "\nA=\n" << A;
return A;
}
extern jobject _javabind_asObjectArray(int dim, jclass clazz,
jobject (*asJava)(OBJ),
OBJ arr){
jsize leng,i, excl; jarray jarr;
excl = excl_array(arr, 1);
leng = leng_array(arr);
jarr = (*javabind_env)->NewObjectArray(javabind_env, leng,
array_type(dim-1, clazz),
NULL);
javabind_catch_abort();
if (dim > 1){
for (i = 0; i < leng; i++){
OBJ subArr = data_array(arr)[i];
jobject jo;
if (!excl) copy_array(subArr, 1);
jo = _javabind_asObjectArray(dim-1, clazz, asJava, subArr);
(*javabind_env)->SetObjectArrayElement(javabind_env, jarr, i, jo);
javabind_catch_abort();
(*javabind_env)->DeleteLocalRef(javabind_env, jo);
}
} else {
/* passing asJava alone doesnt works anymore since 1.1b (the free method
is required as well). Yet, the only unregular treatment of free
currently is for _javabind_asObject; so a quick hack
checking for the function address helps out. */
if (asJava == _javabind_asObject){
for (i = 0; i < leng; i++){
OBJ elem = data_array(arr)[i];
(*javabind_env)->SetObjectArrayElement(javabind_env, jarr, i,
get_jobject(elem));
javabind_catch_abort();
if (excl){
if (excl_jobject(elem, 1)){
_javabind_dispose(elem);
} else {
decr_jobject(elem, 1);
}
}
}
} else {
for (i = 0; i < leng; i++){
OBJ elem = data_array(arr)[i];
jobject jo;
if (!excl) copy_some(elem, 1);
jo = (*asJava)(elem);
(*javabind_env)->SetObjectArrayElement(javabind_env, jarr, i, jo);
javabind_catch_abort();
(*javabind_env)->DeleteLocalRef(javabind_env, jo);
}
}
}
if (excl){
dispose_array_flat(arr);
} else {
decr_array(arr,1);
}
return jarr;
}
static node_t *arrays(bool abstract)
{
node_t *atype = array_type(NULL);
if (abstract) {
if (token->id == '*') {
if (lookahead()->id != ']') {
parse_assign(atype);
} else {
expect('*');
TYPE_A_STAR(atype) = 1;
}
} else if (first_expr(token)) {
parse_assign(atype);
}
} else {
if (token->id == STATIC) {
expect(STATIC);
TYPE_A_STATIC(atype) = 1;
if (token->kind == CONST)
array_qualifiers(atype);
parse_assign(atype);
} else if (token->kind == CONST) {
if (token->kind == CONST)
array_qualifiers(atype);
if (token->id == STATIC) {
expect(STATIC);
TYPE_A_STATIC(atype) = 1;
parse_assign(atype);
} else if (token->id == '*') {
if (lookahead()->id != ']') {
parse_assign(atype);
} else {
expect('*');
TYPE_A_STAR(atype) = 1;
}
} else if (first_expr(token)) {
parse_assign(atype);
}
} else if (token->id == '*') {
if (lookahead()->id != ']') {
parse_assign(atype);
} else {
expect('*');
TYPE_A_STAR(atype) = 1;
}
} else if (first_expr(token)) {
parse_assign(atype);
}
}
return atype;
}
// Parse a postfix-type.
//
// postfix-type
// primary-type
// postfix-type '[]'
// postfix-type '[' expression ']'
//
Type&
Parser::postfix_type()
{
Type* t = &primary_type();
while (true) {
if (match_if(lbracket_tok))
t = &array_type(*t);
else
break;
}
return *t;
}
//--------------------------------------------------------------------------
// Function: CommonFG::openArrayType
///\brief Opens the named array datatype at this location.
///\param name - IN: Name of the array datatype to open
///\return ArrayType instance
///\exception H5::FileIException or H5::GroupIException
// Programmer Binh-Minh Ribler - Jul, 2005
//--------------------------------------------------------------------------
ArrayType CommonFG::openArrayType( const char* name ) const
{
// Call C function H5Topen2 to open the named datatype in this group,
// given either the file or group id
hid_t type_id = H5Topen2(getLocId(), name, H5P_DEFAULT);
// If the datatype's opening failed, throw an exception
if( type_id < 0 )
throwException("openArrayType", "H5Topen2 failed");
// No failure, create and return the ArrayType object
ArrayType array_type (type_id);
return(array_type);
}
/* Given a PyArrayObject, check to see if it is contiguous. If so,
* return the input pointer and flag it as not a new object. If it is
* not contiguous, create a new PyArrayObject using the original data,
* flag it as a new object and return the pointer.
*/
PyArrayObject* make_contiguous(PyArrayObject* ary, int* is_new_object,
int min_dims, int max_dims) {
PyArrayObject* result;
if (array_is_contiguous(ary)) {
result = ary;
*is_new_object = 0;
}
else {
result = (PyArrayObject*) PyArray_ContiguousFromObject((PyObject*)ary,
array_type(ary),
min_dims,
max_dims);
*is_new_object = 1;
}
PyErr_Clear();
return result;
}
/* Convert the given PyObject to a NumPy array with the given
* typecode. On success, return a valid PyArrayObject* with the
* correct type. On failure, the python error string will be set and
* the routine returns NULL.
*/
PyArrayObject* obj_to_array_allow_conversion(PyObject* input, int typecode,
int* is_new_object) {
PyArrayObject* ary = NULL;
PyObject* py_obj;
if (is_array(input) && (typecode == NPY_NOTYPE ||
PyArray_EquivTypenums(array_type(input),typecode))) {
ary = (PyArrayObject*) input;
*is_new_object = 0;
}
else {
py_obj = PyArray_FromObject(input, typecode, 0, 0);
/* If NULL, PyArray_FromObject will have set python error value.*/
ary = (PyArrayObject*) py_obj;
*is_new_object = 1;
}
PyErr_Clear();
return ary;
}
static AST mod(AST elem) {
Token *t = &tok;
AST a,a1=0;
int sz;
a = elem;
if (t->sym == '[') {
gettoken();
a1 = con();
sz = get_ival(a1);
if (sz <= 0) { parse_error("size must be positive"); sz = 1; }
if (t->sym == ']') gettoken();
else parse_error("expected ]");
a = array_type(gen(tGLOBAL), elem, sz);
a = mod(a);
}
return a;
}
const complex_matrix_type make_ug( const matrix_type& G, const matrix_type& A, const matrix_type& D ) const
{
assert( G.col() == 3 );
assert( A.col() == 3 );
assert( D.col() == 1 );
assert( A.row() == D.row() );
auto const M = make_matrix();
auto const S = G * ( M.inverse() );
matrix_type s( 1, S.row() );
for ( size_type i = 0; i < S.row(); ++ i )
{
s[0][i] = value_type( 0.5 ) * std::sqrt( std::inner_product( S.row_begin( i ), S.row_end( i ), S.row_begin( i ), value_type( 0 ) ) );
}
auto const piomega = 3.141592553590 * feng::inner_product( array_type( M[0][0], M[1][0], M[2][0] ),
feng::cross_product( array_type( M[0][1], M[1][1], M[2][1] ), array_type( M[0][2], M[1][2], M[2][2] ) ) );
auto const atomcellfacte = make_gaussian_electron( s, v0 );
const complex_matrix_type dwss = D * feng::pow( s, value_type( 2 ) );
const complex_matrix_type piag = A * G.transpose();
auto fact = feng::exp( - dwss - piag * complex_type( 0, 6.2831853071796 ) );
std::transform( fact.begin(), fact.end(), atomcellfacte.begin(), fact.begin(), [piomega]( const complex_type f, const value_type a )
{
return f * a / piomega;
} );
complex_matrix_type Ug( fact.col(), 1 );
for ( size_type i = 0; i < fact.col(); ++i )
{
Ug[i][0] = std::accumulate( fact.col_begin( i ), fact.col_end( i ), complex_type() );
//if ( std::abs(Ug[i][0].real()) < 1.0e-8 ) Ug[i][0].real(0);
//if ( std::abs(Ug[i][0].imag()) < 1.0e-8 ) Ug[i][0].imag(0);
}
return Ug;
}
bool ECResyncSet::Remove(const SBinary &sbinSourceKey)
{
return m_map.erase(array_type(sbinSourceKey.lpb, sbinSourceKey.lpb + sbinSourceKey.cb)) == 1;
}
void ECResyncSet::Append(const SBinary &sbinSourceKey, const SBinary &sbinEntryID, const FILETIME &lastModTime)
{
m_map.insert(map_type::value_type(
array_type(sbinSourceKey.lpb, sbinSourceKey.lpb + sbinSourceKey.cb),
storage_type(array_type(sbinEntryID.lpb, sbinEntryID.lpb + sbinEntryID.cb), lastModTime)));
}
static HRESULT WINAPI convert_CanConvert(IDataConvert* iface,
DBTYPE src_type, DBTYPE dst_type)
{
convert *This = impl_from_IDataConvert(iface);
DBTYPE src_base_type = src_type & 0x1ff;
DBTYPE dst_base_type = dst_type & 0x1ff;
WORD dst_class = get_dbtype_class(dst_base_type);
TRACE("(%p)->(%d, %d)\n", This, src_type, dst_type);
if(src_type & DBTYPE_VECTOR || dst_type & DBTYPE_VECTOR) return S_FALSE;
if(src_type & DBTYPE_ARRAY)
{
if(!array_type(src_base_type)) return S_FALSE;
if(dst_type & DBTYPE_ARRAY)
{
if(src_type == dst_type) return S_OK;
return S_FALSE;
}
if(dst_type == DBTYPE_VARIANT) return S_OK;
return S_FALSE;
}
if(dst_type & DBTYPE_ARRAY)
{
if(!array_type(dst_base_type)) return S_FALSE;
if(src_type == DBTYPE_IDISPATCH || src_type == DBTYPE_VARIANT) return S_OK;
return S_FALSE;
}
if(dst_type & DBTYPE_BYREF)
if(dst_base_type != DBTYPE_BYTES && dst_base_type != DBTYPE_STR && dst_base_type != DBTYPE_WSTR)
return S_FALSE;
switch(get_dbtype_class(src_base_type))
{
case DBTYPE_EMPTY:
if(common_class(dst_class)) return S_OK;
switch(dst_class)
{
case DBTYPE_DATE:
case DBTYPE_GUID:
case DBTYPE_FILETIME:
return S_OK;
default:
if(dst_base_type == DBTYPE_DBTIMESTAMP) return S_OK;
return S_FALSE;
}
case DBTYPE_NULL:
switch(dst_base_type)
{
case DBTYPE_NULL:
case DBTYPE_VARIANT:
case DBTYPE_FILETIME: return S_OK;
default: return S_FALSE;
}
case DBTYPE_I4:
if(dst_base_type == DBTYPE_BYTES) return S_OK;
/* fall through */
case DBTYPE_I2:
if(dst_base_type == DBTYPE_DATE) return S_OK;
/* fall through */
case DBTYPE_DECIMAL:
if(common_class(dst_class)) return S_OK;
if(dst_class == DBTYPE_DBDATE) return S_OK;
return S_FALSE;
case DBTYPE_BOOL:
if(dst_base_type == DBTYPE_DATE) return S_OK;
/* fall through */
case DBTYPE_NUMERIC:
case DBTYPE_CY:
if(common_class(dst_class)) return S_OK;
return S_FALSE;
case DBTYPE_I8:
if(common_class(dst_class)) return S_OK;
switch(dst_base_type)
{
case DBTYPE_BYTES:
case DBTYPE_FILETIME: return S_OK;
default: return S_FALSE;
}
case DBTYPE_DATE:
switch(dst_class)
{
case DBTYPE_EMPTY:
case DBTYPE_NULL:
case DBTYPE_I2:
case DBTYPE_I4:
case DBTYPE_BSTR:
case DBTYPE_BOOL:
case DBTYPE_VARIANT:
case DBTYPE_I8:
case DBTYPE_DATE:
case DBTYPE_DBDATE:
case DBTYPE_FILETIME:
return S_OK;
default: return S_FALSE;
}
case DBTYPE_IDISPATCH:
case DBTYPE_VARIANT:
switch(dst_base_type)
{
case DBTYPE_IDISPATCH:
case DBTYPE_ERROR:
case DBTYPE_IUNKNOWN:
return S_OK;
}
/* fall through */
case DBTYPE_BSTR:
if(common_class(dst_class)) return S_OK;
switch(dst_class)
{
case DBTYPE_DATE:
case DBTYPE_GUID:
case DBTYPE_BYTES:
case DBTYPE_DBDATE:
case DBTYPE_FILETIME:
return S_OK;
default: return S_FALSE;
}
case DBTYPE_ERROR:
switch(dst_base_type)
{
case DBTYPE_BSTR:
case DBTYPE_ERROR:
case DBTYPE_VARIANT:
case DBTYPE_WSTR:
return S_OK;
default: return S_FALSE;
}
case DBTYPE_IUNKNOWN:
switch(dst_base_type)
{
case DBTYPE_EMPTY:
case DBTYPE_NULL:
case DBTYPE_IDISPATCH:
case DBTYPE_VARIANT:
case DBTYPE_IUNKNOWN:
return S_OK;
default: return S_FALSE;
}
case DBTYPE_BYTES:
if(dst_class == DBTYPE_I4 || dst_class == DBTYPE_I8) return S_OK;
/* fall through */
case DBTYPE_GUID:
switch(dst_class)
{
case DBTYPE_EMPTY:
case DBTYPE_NULL:
case DBTYPE_BSTR:
case DBTYPE_VARIANT:
case DBTYPE_GUID:
case DBTYPE_BYTES:
return S_OK;
default: return S_FALSE;
}
case DBTYPE_FILETIME:
if(dst_class == DBTYPE_I8) return S_OK;
/* fall through */
case DBTYPE_DBDATE:
switch(dst_class)
{
case DBTYPE_EMPTY:
case DBTYPE_NULL:
case DBTYPE_DATE:
case DBTYPE_BSTR:
case DBTYPE_VARIANT:
case DBTYPE_DBDATE:
case DBTYPE_FILETIME:
return S_OK;
default: return S_FALSE;
}
}
return S_FALSE;
}
ciType* element_type() { return array_type()->element_type(); }
shared_array_memory(size_type Size_,const T& t_):Ptr(Pool.construct(array_type(Size_,t_))){}
