Concatenate a value to this tuple.
974325
public final <T5> Tuple5<T1, T2, T3, T4, T5> concat(T5 value) {
        return new Tuple5<>(v1, v2, v3, v4, value);
    }
1367592
def spread_value(value: Decimal, spread_p: Decimal) -> Tuple[Decimal, Decimal]:
    """"""
    upper = value * (1 + spread_p)
    lower = value / (1 + spread_p)
    return lower, upper
700132
def to_tuple(self, iterable, surround="()", joiner=", "):
    """"""
    return "{0}{1}{2}".format(surround[0], joiner.join(iterable), surround[1])
1146350
def option2tuple(opt):
    """"""

    if isinstance(opt[0], int):
        tup = opt[1], opt[2:]
    else:
        tup = opt[0], opt[1:]

    return tup
292726
def append(self, val):
        
        self.values.append(val)
        self.value = self.values[0]
814304
def ver_str_to_tuple(ver_str):
    """"""
    out = []
    for x in ver_str.split("."):
        try:
            x = int(x)
        except ValueError:
            pass
        out.append(x)
    return tuple(out)
490544
def pack_tuple(self, values):
        
        assert isinstance(values, (tuple, list))
        cardinality = [struct_L.pack(len(values))]
        packed_items = [self.pack_field(v) for v in values]
        return b''.join(itertools.chain(cardinality, packed_items))
535835
def append_value(dictionary, key, item):
    """"""
    items = dictionary.get(key, [])
    items.append(item)
    dictionary[key] = items
1337699
private Tuple toTuple( List<VarDef> combinedVars, TupleRef tupleRef)
    {
    if( tupleRef.size() != getTupleSize())
      {
      throw new IllegalStateException( String.valueOf( tupleRef) + " does not match combiner tuple size=" + getTupleSize());
      }

    Tuple tuple = new Tuple();
    for( Iterator<VarBinding> bindings = tupleRef.getVarBindings(); bindings.hasNext(); )
      {
      VarBinding binding = bindings.next();
      VarDef var = findVarPath( combinedVars, binding.getVar());
      if( var == null)
        {
        throw new IllegalStateException( "Var=" + binding.getVar() + " is not included in this combination");
        }

      VarValueDef value = var.getValue( binding.getValue());
      if( value == null)
        {
        throw new IllegalStateException( "Value=" + binding.getValue() + " is not defined for var=" + binding.getVar());
        }

      if( !value.isValid())
        {
        throw new IllegalStateException( "Value=" + binding.getValue() + " is a failure value for var=" + binding.getVar());
        }

      tuple.add( new VarBindingDef( var, value));
      }

    return tuple;
    }
242147
public final <T3, T4> Tuple4<T1, T2, T3, T4> concat(Tuple2<T3, T4> tuple) {
        return new Tuple4<>(v1, v2, tuple.v1, tuple.v2);
    }
446545
def tuplewrap(value):
    
    if is_many(value):
        return tuple(tuplewrap(v) if is_sequence(v) else v for v in value)
    return unwrap(value),
303462
def prepare_value(value):
        """"""
        if isinstance(value, (list, tuple, set)):
            return ",".join(value)

        if isinstance(value, bool):
            return "y" if value else "n"

        return str(value)
67070
public final <T4> Tuple4<T1, T2, T3, T4> concat(Tuple1<T4> tuple) {
        return new Tuple4<>(v1, v2, v3, tuple.v1);
    }
581856
def add(self, name, attr=None, value=None):
        ""

        if isinstance(name, tuple) or isinstance(name, list):
            name, attr, value = self.__set_iter_value(name)

        if attr is None:
            attr = name

        if value is None:
            value = attr

        self.__data += (self.get_const_string(name=name, value=value),)
        # set attribute as slugfiy
        self.__dict__[s_attr(attr)] = self.__data[-1]
1004646
def append(self, mode, metric, step, value):
    """"""
    if mode not in self._values:
      self._values[mode] = collections.defaultdict(list)
    self._values[mode][metric].append((step, value))
224882
def append(self, value):
        
        self.count += 1

        if self.count == 1:
            self.old_m = self.new_m = value
            self.old_s = 0
        else:
            self.new_m = self.old_m + (value - self.old_m) / self.count
            self.new_s = self.old_s + (value - self.old_m) * (value - self.new_m)

            self.old_m = self.new_m
            self.old_s = self.new_s
230824
def _concat(self, first_data, second_data):
        """"""
        assert len(first_data) == len(
            second_data), 'data source should contain the same size'
        if first_data and second_data:
            return [
                concat(
                    first_data[x],
                    second_data[x],
                    dim=0
                ) for x in range(len(first_data))
            ]
        elif (not first_data) and (not second_data):
            return []
        else:
            return [
                first_data[0] if first_data else second_data[0]
                for x in range(len(first_data))
            ]