diff --git a/hysop/backend/device/codegen/base/variables.py b/hysop/backend/device/codegen/base/variables.py
index cdcf6e586face2875622d63ee34c86216bfe9d1d..2bd543e648981a4bf9c4a7c1895091d428a68784 100644
--- a/hysop/backend/device/codegen/base/variables.py
+++ b/hysop/backend/device/codegen/base/variables.py
@@ -77,7 +77,7 @@ def dtype_to_ctype(dtype):
from hysop.tools.numerics import get_dtype
dtype = get_dtype(dtype)
if dtype not in _dtype_to_ctype.keys():
- msg='Unknown dtype {}.'.format(dtype)
+ msg=f'Unknown dtype {dtype}.'
raise ValueError(msg)
else:
return _dtype_to_ctype[dtype]
@@ -93,7 +93,7 @@ def register_ctype_dtype(ctype,dtype):
if ctype not in _ctype_to_dtype.keys():
_ctype_to_dtype[ctype] = dtype
-class CodegenVariable(object):
+class CodegenVariable:
def __init__(self, name, ctype, typegen,
storage=None, const=False, volatile=False, static=False,
@@ -280,7 +280,7 @@ class CodegenVariable(object):
ptr_volatile = self.ptr_volatile + ptr_volatile
ptr_restrict = self.ptr_restrict + ptr_restrict
if with_init:
- init = '&{}'.format(self.name)
+ init = f'&{self.name}'
else:
init = None
return self.newvar(name=name, ptr=ptr_level,
@@ -309,7 +309,7 @@ class CodegenVariable(object):
const |= (storage is not None) and ('__constant' in storage)
base_ctype = '{storage}${static}${const}${volatile}${ctype}'.format(
- storage='{} '.format(storage) if (storage is not None) else '',
+ storage=f'{storage} ' if (storage is not None) else '',
static='static ' if static else '',
const='const ' if const else '',
volatile='volatile ' if volatile else '',
@@ -346,12 +346,12 @@ class CodegenVariable(object):
base_ctype = self.base_ctype(storage,ctype,const,volatile,impl,align,
add_impl_const=add_impl_const, **kwds)
if len(base_ctype)==0:
- msg= 'Failed to get base ctype in {}.'.format(self.__class__)
+ msg= f'Failed to get base ctype in {self.__class__}.'
raise RuntimeError(msg)
ptr_ctype = self.ptr_ctype(impl=impl, add_impl_const=add_impl_const, cast=cast)
- full_ctype = '{}{}'.format(base_ctype, ptr_ctype)
+ full_ctype = f'{base_ctype}{ptr_ctype}'
if not align:
full_ctype = full_ctype.replace('$', '')
else:
@@ -381,7 +381,7 @@ class CodegenVariable(object):
return
self.symbolic_mode = force
def set_value(self, val):
- assert not self.known(), 'Value was already set in variable {}!'.format(self.name)
+ assert not self.known(), f'Value was already set in variable {self.name}!'
self.value = val
def sval(self, symbolic=None):
@@ -419,7 +419,7 @@ class CodegenVariable(object):
align = first_not_None(align, self.align, False)
ctype = self.full_ctype(align=align,multidecl=multidecl,add_impl_const=const, const=_const, **kwds)
if (not multidecl) and len(ctype)==0:
- msg= 'Failed to get full ctype in {}.'.format(self.__class__)
+ msg= f'Failed to get full ctype in {self.__class__}.'
raise RuntimeError(msg)
# static array ctype needs to be split
@@ -432,22 +432,22 @@ class CodegenVariable(object):
else:
init = init if (init is not None) else self.init
if (len(ctype)>0) and ctype[-1]=='*':
- code = '{}${}'.format(ctype, name)
+ code = f'{ctype}${name}'
else:
- code = '{} ${}'.format(ctype, name)
+ code = f'{ctype} ${name}'
if (init is not None):
if compact:
- code = '{}={}'.format(code, init)
+ code = f'{code}={init}'
else:
- code = '{} $= {}'.format(code, init)
+ code = f'{code} $= {init}'
elif self.known():
self.force_symbolic(False)
sval = self.sval()
if compact:
- code = '{}={}'.format(code,sval)
+ code = f'{code}={sval}'
else:
- code = '{} $= {}'.format(code,sval)
+ code = f'{code} $= {sval}'
if not multidecl:
code+=';'
@@ -488,17 +488,17 @@ class CodegenVariable(object):
def __getitem__(self,ss):
if self.is_ptr:
- return '{}[{}]'.format(self.name,ss)
+ return f'{self.name}[{ss}]'
elif ss==0:
return self.__call__()
else:
- assert self.is_ptr, '{} is not a pointer!'.format(self.name)
+ assert self.is_ptr, f'{self.name} is not a pointer!'
def __repr__(self):
if self.is_symbolic():
- return '{}({})'.format(self.name,self.ctype)
+ return f'{self.name}({self.ctype})'
else:
- return '{}({},{})'.format(self.name,self.ctype,self.value)
+ return f'{self.name}({self.ctype},{self.value})'
def __call__(self):
return self.sval()
@@ -535,7 +535,7 @@ class CodegenArray(CodegenVariable):
_value = [None]*s0
_svalue = [None]*s0
for d in range(s0):
- _name = '{}_{}'.format(name, d)
+ _name = f'{name}_{d}'
dvalue = value[d]
dsvalue = svalue[d]
val, sval = CodegenArray._initialize_rec(_name, typegen,
@@ -628,7 +628,7 @@ class CodegenArray(CodegenVariable):
ptr_level, ptr_restrict, ptr_const, ptr_volatile,
symbolic_mode)
- super(CodegenArray, self).__init__(name=name,
+ super().__init__(name=name,
storage=storage, ctype=ctype, typegen=typegen,
value=_value, svalue=_svalue,
const=const, add_impl_const=add_impl_const, volatile=volatile,
@@ -639,9 +639,9 @@ class CodegenArray(CodegenVariable):
def decl_name(self):
if self.shape is not None:
- static_array = ['[{}]'.format(val) for val in self.shape]
+ static_array = [f'[{val}]' for val in self.shape]
elif self.sshape is not None:
- static_array = ['[{}]'.format(val) for val in self.sshape]
+ static_array = [f'[{val}]' for val in self.sshape]
else:
static_array = []
return '{}{}'.format(self.name, ''.join(static_array))
@@ -687,7 +687,7 @@ class CodegenVector(CodegenVariable):
add_impl_const=False, nl=None,
symbolic_mode=False, struct_var=None,
init=None):
- super(CodegenVector,self).__init__(name=name,ctype=ctype,value=value,typegen=typegen,
+ super().__init__(name=name,ctype=ctype,value=value,typegen=typegen,
const=const, volatile=volatile, add_impl_const=add_impl_const,
storage=storage, nl=nl,
ptr=ptr, ptr_const=ptr_const, ptr_volatile=ptr_volatile, ptr_restrict=ptr_restrict,
@@ -710,7 +710,7 @@ class CodegenVector(CodegenVariable):
if i is not None:
assert i<self.dim
if self.is_symbolic():
- return '{}{}[{}]'.format(self.access_prefix(False),self.name,i)
+ return f'{self.access_prefix(False)}{self.name}[{i}]'
else:
return self.svalue[i]
else:
@@ -725,10 +725,10 @@ class CodegenVector(CodegenVariable):
def __repr__(self):
if self.is_symbolic():
- return '{}({})'.format(self.name,self.ctype)
+ return f'{self.name}({self.ctype})'
else:
vals = '['+','.join(self.svalue)+']'
- return '{}({},{})'.format(self.name,self.ctype,vals)
+ return f'{self.name}({self.ctype},{vals})'
class CodegenVectorClBuiltin(CodegenVector):
@@ -746,11 +746,11 @@ class CodegenVectorClBuiltin(CodegenVector):
if (dim > 1):
ctype = btype+str(dim)
access_mode = access_mode if access_mode else ('pos' if dim<=4 else 'hex')
- msg='Wrong vector size {}'.format(dim)
+ msg=f'Wrong vector size {dim}'
assert dim in typegen.vsizes
- msg='Invalid basetype {} for vector.'.format(btype)
+ msg=f'Invalid basetype {btype} for vector.'
assert btype in (typegen.float_base_types + typegen.signed_base_types + typegen.unsigned_base_types), msg
- msg='Invalid builtin type {}.'.format(ctype)
+ msg=f'Invalid builtin type {ctype}.'
assert ctype in typegen.builtin_types, ctype
else:
# scalar type
@@ -764,7 +764,7 @@ class CodegenVectorClBuiltin(CodegenVector):
assert value.size == dim
svalue = [typegen.dump(np.asarray([f],dtype=dtype)[0]) for f in value]
- super(CodegenVectorClBuiltin,self).__init__(name=name,ctype=ctype,dim=dim,typegen=typegen,
+ super().__init__(name=name,ctype=ctype,dim=dim,typegen=typegen,
value=value,svalue=svalue, const=const, add_impl_const=add_impl_const,
storage=storage, nl=nl, symbolic_mode=symbolic_mode, struct_var=struct_var,
init=init)
@@ -774,7 +774,7 @@ class CodegenVectorClBuiltin(CodegenVector):
def newvar(self, name, btype=None, dim=None, **kwds):
btype = first_not_None(btype, self.btype)
dim = first_not_None(dim, self.dim)
- return super(CodegenVectorClBuiltin, self).newvar(name=name, btype=btype, dim=dim,
+ return super().newvar(name=name, btype=btype, dim=dim,
**kwds)
def view(self, name, components, const=False):
@@ -786,7 +786,7 @@ class CodegenVectorClBuiltin(CodegenVector):
it = tuple(range(self.dim))
dim = self.dim
else:
- raise ValueError('Unknown components type {}.'.format(components.__class__.__name__))
+ raise ValueError(f'Unknown components type {components.__class__.__name__}.')
if dim>self.dim:
raise ValueError('Dimension of view is greater than original vector!')
@@ -813,7 +813,7 @@ class CodegenVectorClBuiltin(CodegenVector):
if (self.value != value).any():
if self.known():
- msg='Value was already set in variable {}!'.format(self.name)
+ msg=f'Value was already set in variable {self.name}!'
raise RuntimeError(msg)
self.value = value
@@ -865,21 +865,21 @@ class CodegenVectorClBuiltin(CodegenVector):
if key<0:
key += dim
if key<0 or key>=dim:
- raise IndexError("The index {} is out of range.".format(key))
+ raise IndexError(f"The index {key} is out of range.")
return self.sval(key)
else:
- msg='Invalid key type {}!'.format(type(key))
+ msg=f'Invalid key type {type(key)}!'
raise TypeError(msg)
def declare(self, codegen=None, init=None, **kargs):
init = first_not_None(init, self.init)
if isinstance(init, int):
init = ','.join([self.typegen.dump(init) for _ in range(self.dim)])
- init = '({})({})'.format(self.ctype,init)
+ init = f'({self.ctype})({init})'
elif init.__class__ in [list,tuple,np.ndarray]:
init = ','.join([self.typegen.dump(init[i]) for i in range(self.dim)])
- init = '({})({})'.format(self.ctype,init)
- return super(CodegenVectorClBuiltin,self).declare(init=init, codegen=codegen, **kargs)
+ init = f'({self.ctype})({init})'
+ return super().declare(init=init, codegen=codegen, **kargs)
class CodegenVectorClBuiltinFunc(CodegenVectorClBuiltin):
@@ -887,7 +887,7 @@ class CodegenVectorClBuiltinFunc(CodegenVectorClBuiltin):
value=None,access_mode='pos',
symbolic_mode=False,
const=False):
- super(CodegenVectorClBuiltinFunc,self).__init__(name=name,btype=btype,dim=dim,typegen=typegen,
+ super().__init__(name=name,btype=btype,dim=dim,typegen=typegen,
value=value,access_mode=access_mode,const=const,symbolic_mode=symbolic_mode)
self.fname = fname
@@ -897,14 +897,14 @@ class CodegenVectorClBuiltinFunc(CodegenVectorClBuiltin):
return '({})({})'.format(self.ctype, ','.join(value))
else:
assert i<self.dim
- return 'get_{}({})'.format(self.fname,i)
+ return f'get_{self.fname}({i})'
def declare(self, codegen=None, init=None, **kargs):
if init is False:
init = None
else:
init = self.fval() if not self.known() else init
- return super(CodegenVectorClBuiltinFunc,self).declare(init=init, codegen=codegen, **kargs)
+ return super().declare(init=init, codegen=codegen, **kargs)
class CodegenStruct(CodegenVariable):
def __init__(self, name, struct,
@@ -916,7 +916,7 @@ class CodegenStruct(CodegenVariable):
value=None,
var_overrides=None):
- super(CodegenStruct,self).__init__(
+ super().__init__(
name=name,
ctype=struct.ctype,
typegen=struct.typegen,
@@ -933,12 +933,12 @@ class CodegenStruct(CodegenVariable):
def newvar(self, *args, **kwds):
kwds.setdefault('cls', CodegenVariable)
- return super(CodegenStruct, self).newvar(*args, **kwds)
+ return super().newvar(*args, **kwds)
def force_symbolic(self, force=True):
if force is None:
return
- super(CodegenStruct,self).force_symbolic(force)
+ super().force_symbolic(force)
for k,var in self.vars.items():
var.force_symbolic(force)
@@ -992,7 +992,7 @@ class CodegenStruct(CodegenVariable):
if fieldname in var_overrides.keys():
pass
elif (fieldname not in self.value.keys()):
- raise ValueError('Value was given but field {} is not present.'.format(fieldname))
+ raise ValueError(f'Value was given but field {fieldname} is not present.')
else:
field_value = self.value[fieldname]
else:
@@ -1027,7 +1027,7 @@ class CodegenStruct(CodegenVariable):
decl = var()
decl = decl.replace('\n', '\n\t')
- sval = '.{} $= {}'.format(fieldname,decl)
+ sval = f'.{fieldname} $= {decl}'
svalue.append(sval)
var.force_symbolic(self.symbolic_mode)