Detail: Batch: Accessor TransposeΒΆ

Overview: Batch: Accessor Transpose

Batch.via_T.via_fill_value(fill_value)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.via_fill_value(fill_value)[source]

Interface for using binary operators and methods with a pre-defined fill value.

>>> 
Batch.via_T.__add__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__add__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T + s).to_frame()
<Frame>
<Index>                a         b         c         <<U1>
<IndexHierarchy>
i                p     10.0      8.0       1.0
i                q     -4.0      -5.0      -2.0
i                r     0.5       8.5       9.5
i                s     1.0       1.0       13.0
j                p     1.0       2.0       1.0
j                q     0.0       -1.0      -2.0
j                r     0.5       2.5       2.5
j                s     1.0       1.0       2.0
<<U1>            <<U1> <float64> <float64> <float64>
Batch.via_T.__sub__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__sub__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T - s).to_frame()
<Frame>
<Index>                a         b         c         <<U1>
<IndexHierarchy>
i                p     10.0      8.0       1.0
i                q     0.0       -1.0      2.0
i                r     -0.5      7.5       8.5
i                s     -1.0      -1.0      11.0
j                p     1.0       2.0       1.0
j                q     4.0       3.0       2.0
j                r     -0.5      1.5       1.5
j                s     -1.0      -1.0      0.0
<<U1>            <<U1> <float64> <float64> <float64>
Batch.via_T.__mul__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__mul__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T * s).to_frame()
<Frame>
<Index>                a         b         c         <<U1>
<IndexHierarchy>
i                p     0.0       0.0       0.0
i                q     4.0       6.0       -0.0
i                r     0.0       4.0       4.5
i                s     0.0       0.0       12.0
j                p     0.0       0.0       0.0
j                q     -4.0      -2.0      -0.0
j                r     0.0       1.0       1.0
j                s     0.0       0.0       1.0
<<U1>            <<U1> <float64> <float64> <float64>
Batch.via_T.__truediv__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__truediv__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T / s).to_frame()
<Frame>
<Index>                a         b         c         <<U1>
<IndexHierarchy>
i                p     inf       inf       inf
i                q     1.0       1.5       -0.0
i                r     0.0       16.0      18.0
i                s     0.0       0.0       12.0
j                p     inf       inf       inf
j                q     -1.0      -0.5      -0.0
j                r     0.0       4.0       4.0
j                s     0.0       0.0       1.0
<<U1>            <<U1> <float64> <float64> <float64>
Batch.via_T.__floordiv__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__floordiv__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T // s).to_frame()
<Frame>
<Index>                a         b         c         <<U1>
<IndexHierarchy>
i                p     nan       nan       nan
i                q     1.0       1.0       -0.0
i                r     0.0       16.0      18.0
i                s     0.0       0.0       12.0
j                p     nan       nan       nan
j                q     -1.0      -1.0      -0.0
j                r     0.0       4.0       4.0
j                s     0.0       0.0       1.0
<<U1>            <<U1> <float64> <float64> <float64>
Batch.via_T.__mod__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__mod__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T % s).to_frame()
<Frame>
<Index>                a         b         c         <<U1>
<IndexHierarchy>
i                p     nan       nan       nan
i                q     -0.0      -1.0      -0.0
i                r     0.0       0.0       0.0
i                s     0.0       0.0       0.0
j                p     nan       nan       nan
j                q     -0.0      -1.0      -0.0
j                r     0.0       0.0       0.0
j                s     0.0       0.0       0.0
<<U1>            <<U1> <float64> <float64> <float64>
Batch.via_T.__pow__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__pow__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T ** s).to_frame()
<Frame>
<Index>                a         b                  c                  <<U1>
<IndexHierarchy>
i                p     1.0       1.0                1.0
i                q     0.25      0.1111111111111111 inf
i                r     0.0       2.8284271247461903 3.0
i                s     0.0       0.0                12.0
j                p     1.0       1.0                1.0
j                q     0.25      1.0                inf
j                r     0.0       1.4142135623730951 1.4142135623730951
j                s     0.0       0.0                1.0
<<U1>            <<U1> <float64> <float64>          <float64>
Batch.via_T.__lshift__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__lshift__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 3, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T << s).to_frame()
<Frame>
<Index>                a       b       c       <<U1>
<IndexHierarchy>
i                p     10      8       1
i                q     0       0       0
i                r     0       64      72
i                s     0       0       24
j                p     1       2       1
j                q     0       0       0
j                r     0       16      16
j                s     0       0       2
<<U1>            <<U1> <int64> <int64> <int64>
Batch.via_T.__rshift__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__rshift__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 3, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T >> s).to_frame()
<Frame>
<Index>                a       b       c       <<U1>
<IndexHierarchy>
i                p     10      8       1
i                q     -1      -1      0
i                r     0       1       1
i                s     0       0       6
j                p     1       2       1
j                q     0       0       0
j                r     0       0       0
j                s     0       0       0
<<U1>            <<U1> <int64> <int64> <int64>
Batch.via_T.__and__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__and__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame((np.arange(6).reshape(3,2) % 2).astype(bool), index=('p', 'q', 'r'), columns=('c', 'd'), name='y')), ('j', sf.Frame((np.arange(6).reshape(3,2) % 3).astype(bool), index=('p', 'q', 'r'), columns=('c', 'd'), name='w'))))
>>> s = sf.Series((False, True, True), index=('p', 'q', 'r'))
>>> (bt.via_T & s).to_frame()
<Frame>
<Index>                c      d      <<U1>
<IndexHierarchy>
i                p     False  False
i                q     False  True
i                r     False  True
j                p     False  False
j                q     True   False
j                r     True   True
<<U1>            <<U1> <bool> <bool>
Batch.via_T.__xor__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__xor__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame((np.arange(6).reshape(3,2) % 2).astype(bool), index=('p', 'q', 'r'), columns=('c', 'd'), name='y')), ('j', sf.Frame((np.arange(6).reshape(3,2) % 3).astype(bool), index=('p', 'q', 'r'), columns=('c', 'd'), name='w'))))
>>> s = sf.Series((False, True, True), index=('p', 'q', 'r'))
>>> (bt.via_T ^ s).to_frame()
<Frame>
<Index>                c      d      <<U1>
<IndexHierarchy>
i                p     False  True
i                q     True   False
i                r     True   False
j                p     False  True
j                q     False  True
j                r     False  False
<<U1>            <<U1> <bool> <bool>
Batch.via_T.__or__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__or__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame((np.arange(6).reshape(3,2) % 2).astype(bool), index=('p', 'q', 'r'), columns=('c', 'd'), name='y')), ('j', sf.Frame((np.arange(6).reshape(3,2) % 3).astype(bool), index=('p', 'q', 'r'), columns=('c', 'd'), name='w'))))
>>> s = sf.Series((False, True, True), index=('p', 'q', 'r'))
>>> (bt.via_T | s).to_frame()
<Frame>
<Index>                c      d      <<U1>
<IndexHierarchy>
i                p     False  True
i                q     True   True
i                r     True   True
j                p     False  True
j                q     True   True
j                r     True   True
<<U1>            <<U1> <bool> <bool>
Batch.via_T.__lt__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__lt__(other)[source]

Return self<value.

>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T < s).to_frame()
<Frame>
<Index>                a      b      c      <<U1>
<IndexHierarchy>
i                p     False  False  False
i                q     False  True   False
i                r     True   False  False
i                s     True   True   False
j                p     False  False  False
j                q     False  False  False
j                r     True   False  False
j                s     True   True   False
<<U1>            <<U1> <bool> <bool> <bool>
Batch.via_T.__le__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__le__(other)[source]

Return self<=value.

>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T <= s).to_frame()
<Frame>
<Index>                a      b      c      <<U1>
<IndexHierarchy>
i                p     False  False  False
i                q     True   True   False
i                r     True   False  False
i                s     True   True   False
j                p     False  False  False
j                q     False  False  False
j                r     True   False  False
j                s     True   True   True
<<U1>            <<U1> <bool> <bool> <bool>
Batch.via_T.__eq__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__eq__(other)[source]

Return self==value.

>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T == s).to_frame()
<Frame>
<Index>                a      b      c      <<U1>
<IndexHierarchy>
i                p     False  False  False
i                q     True   False  False
i                r     False  False  False
i                s     False  False  False
j                p     False  False  False
j                q     False  False  False
j                r     False  False  False
j                s     False  False  True
<<U1>            <<U1> <bool> <bool> <bool>
Batch.via_T.__ne__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__ne__(other)[source]

Return self!=value.

>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T != s).to_frame()
<Frame>
<Index>                a      b      c      <<U1>
<IndexHierarchy>
i                p     True   True   True
i                q     False  True   True
i                r     True   True   True
i                s     True   True   True
j                p     True   True   True
j                q     True   True   True
j                r     True   True   True
j                s     True   True   False
<<U1>            <<U1> <bool> <bool> <bool>
Batch.via_T.__gt__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__gt__(other)[source]

Return self>value.

>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T > s).to_frame()
<Frame>
<Index>                a      b      c      <<U1>
<IndexHierarchy>
i                p     True   True   True
i                q     False  False  True
i                r     False  True   True
i                s     False  False  True
j                p     True   True   True
j                q     True   True   True
j                r     False  True   True
j                s     False  False  False
<<U1>            <<U1> <bool> <bool> <bool>
Batch.via_T.__ge__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__ge__(other)[source]

Return self>=value.

>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T >= s).to_frame()
<Frame>
<Index>                a      b      c      <<U1>
<IndexHierarchy>
i                p     True   True   True
i                q     True   False  True
i                r     False  True   True
i                s     False  False  True
j                p     True   True   True
j                q     True   True   True
j                r     False  True   True
j                s     False  False  True
<<U1>            <<U1> <bool> <bool> <bool>
Batch.via_T.__radd__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__radd__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T + s).to_frame()
<Frame>
<Index>                a         b         c         <<U1>
<IndexHierarchy>
i                p     10.0      8.0       1.0
i                q     -4.0      -5.0      -2.0
i                r     0.5       8.5       9.5
i                s     1.0       1.0       13.0
j                p     1.0       2.0       1.0
j                q     0.0       -1.0      -2.0
j                r     0.5       2.5       2.5
j                s     1.0       1.0       2.0
<<U1>            <<U1> <float64> <float64> <float64>
Batch.via_T.__rsub__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__rsub__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T - s).to_frame()
<Frame>
<Index>                a         b         c         <<U1>
<IndexHierarchy>
i                p     10.0      8.0       1.0
i                q     0.0       -1.0      2.0
i                r     -0.5      7.5       8.5
i                s     -1.0      -1.0      11.0
j                p     1.0       2.0       1.0
j                q     4.0       3.0       2.0
j                r     -0.5      1.5       1.5
j                s     -1.0      -1.0      0.0
<<U1>            <<U1> <float64> <float64> <float64>
Batch.via_T.__rmul__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__rmul__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T * s).to_frame()
<Frame>
<Index>                a         b         c         <<U1>
<IndexHierarchy>
i                p     0.0       0.0       0.0
i                q     4.0       6.0       -0.0
i                r     0.0       4.0       4.5
i                s     0.0       0.0       12.0
j                p     0.0       0.0       0.0
j                q     -4.0      -2.0      -0.0
j                r     0.0       1.0       1.0
j                s     0.0       0.0       1.0
<<U1>            <<U1> <float64> <float64> <float64>
Batch.via_T.__rtruediv__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__rtruediv__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T / s).to_frame()
<Frame>
<Index>                a         b         c         <<U1>
<IndexHierarchy>
i                p     inf       inf       inf
i                q     1.0       1.5       -0.0
i                r     0.0       16.0      18.0
i                s     0.0       0.0       12.0
j                p     inf       inf       inf
j                q     -1.0      -0.5      -0.0
j                r     0.0       4.0       4.0
j                s     0.0       0.0       1.0
<<U1>            <<U1> <float64> <float64> <float64>
Batch.via_T.__rfloordiv__(other)
Batch.via_T

Interface for using binary operators with one-dimensional sequences, where the opperand is applied column-wise.

InterfaceBatchTranspose.__rfloordiv__(other)[source]
>>> bt = sf.Batch((('i', sf.Frame.from_fields(((10, -2, 0, 0), (8, -3, 8, 0), (1, 0, 9, 12)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x')), ('j', sf.Frame.from_fields(((1, 2, 0, 0), (2, 1, 2, 0), (1, 0, 2, 1)), index=('p', 'q', 'r', 's'), columns=('a', 'b', 'c'), name='x'))))
>>> s = sf.Series((0, -2, 0.5, 1), index=('p', 'q', 'r', 's'))
>>> (bt.via_T // s).to_frame()
<Frame>
<Index>                a         b         c         <<U1>
<IndexHierarchy>
i                p     nan       nan       nan
i                q     1.0       1.0       -0.0
i                r     0.0       16.0      18.0
i                s     0.0       0.0       12.0
j                p     nan       nan       nan
j                q     -1.0      -1.0      -0.0
j                r     0.0       4.0       4.0
j                s     0.0       0.0       1.0
<<U1>            <<U1> <float64> <float64> <float64>

Batch: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Selector | Operator Binary | Operator Unary | Accessor Values | Accessor Datetime | Accessor String | Accessor Transpose | Accessor Fill Value | Accessor Regular Expression | Accessor Hashlib