The size of each state fluent in canonical order.

        Returns:
            Sequence[Sequence[int]]: A tuple of tuple of integers
            representing the shape and size of each fluent.
439672
def state_size(self) -> Sequence[Sequence[int]]:
        '''
        '''
        fluents = self.domain.state_fluents
        ordering = self.domain.state_fluent_ordering
        return self._fluent_size(fluents, ordering)
719651
def size(self):
        
        n = self.number_of_singleton_referents()
        targets = list(self.iter_referents_tuples())
        n_targets = len(targets)
        if n == 0 or n_targets == 0:
            return  0

        #if len(self.__dict__['deferred_effects']) != 0:
        #    return -1 
        size1 = len(list(self.iter_referents_tuples()))
        tlow, thigh = self['targetset_arity'].get_tuple()
        clow, chigh = self['contrast_arity'].get_tuple()
        return size1
1189751
def interm_range_type(self) -> Sequence[str]:
        '''
        '''
        fluents = self.domain.intermediate_fluents
        ordering = self.domain.interm_fluent_ordering
        return self._fluent_range_type(fluents, ordering)
874795
def state_range_type(self) -> Sequence[str]:
        '''
        '''
        fluents = self.domain.state_fluents
        ordering = self.domain.state_fluent_ordering
        return self._fluent_range_type(fluents, ordering)
301560
def sequence(self):
        
        s = scenarios.Scenarios([self.config])
        matrix = s._get_matrix()

        try:
            return matrix[self.name][self.config.subcommand]
        except KeyError:
            # TODO(retr0h): May change this handling in the future.
            return []
987358
def Size(self):
        
        s = super(Block, self).Size() + GetVarSize(self.Transactions)
        return s
752624
def data(self) -> Sequence[Tuple[int, float]]:
        
        return [(num, prob) for num, prob in zip(self._num_cfds_seq,
                                                 self._gnd_state_probs)]
958728
def sequences_to_string(self):
        
        return {k: ''.join(self.states[v]) for (k, v) in self.sequences.items()}
532039
def chunks(seq, chunk_size):
    # type: (Sequence[T], int) -> Iterable[Sequence[T]]
    
    return (seq[i:i + chunk_size] for i in range(0, len(seq), chunk_size))
1000469
def tuple(self):
        
        return tuple(getattr(self, k) for k in self.__class__.defaults)
1229176
def size(self):
        
        if len(self.grouping_column_types) > 1:
            index_type = WeldStruct([self.grouping_column_types])
            # Figure out what to use for multi-key index name
            # index_name = ??
        else:
            index_type = self.grouping_column_types[0]
            index_name = self.grouping_column_names[0]
        return SeriesWeld(
            grizzly_impl.groupby_size(
                self.columns,
                self.column_types,
                self.grouping_columns,
                self.grouping_column_types
            ),
            WeldLong(),
            index_type=index_type,
            index_name=index_name
        )
827688
def state_size(self):
    """"""
    if self._max_unique_stats == 1:
      return (tf.TensorShape([self._hidden_size]),
              tf.TensorShape([self._hidden_size]))
    else:
      return (tf.TensorShape([self._hidden_size]),
              tf.TensorShape([self._hidden_size]),
              tf.TensorShape(1))
543865
def sequence(self):
        
        self.open()
        seq = lvm_vg_get_seqno(self.handle)
        self.close()
        return seq
1033371
def output_sizes(self):
    """"""
    return tuple([l() if callable(l) else l for l in self._output_sizes])
1060125
def Size(self):
        
        script_size = GetVarSize(self.Code.Script)
        parameterlist_size = GetVarSize(self.Code.ParameterList)
        parameterreturntype_size = s.uint8

        return super(ContractState, self).Size() + script_size + parameterlist_size + parameterreturntype_size + s.uint8 + GetVarSize(self.Name) + GetVarSize(self.CodeVersion) + GetVarSize(self.Author) + GetVarSize(self.Email) + GetVarSize(self.Description)
450183
def interm_fluent_ordering(self) -> List[str]:
        '''
        '''
        interm_fluents = self.intermediate_fluents.values()
        key = lambda pvar: (pvar.level, pvar.name)
        return [str(pvar) for pvar in sorted(interm_fluents, key=key)]
43967
def interm_size(self) -> Sequence[Shape]:
        ''''''
        return self._sizes(self._compiler.rddl.interm_size)