Detail: IndexHierarchy: Accessor Transpose

Overview: IndexHierarchy: Accessor Transpose

IndexHierarchy.via_T.via_fill_value(fill_value)

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

InterfaceTranspose.via_fill_value(fill_value)[source]: Interface for using binary operators and methods with a pre-defined fill value.

>>>

IndexHierarchy.via_T.__add__(other)

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

InterfaceTranspose.__add__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T + (0, 1, 1, -1)
[[0.000e+00 1.024e+03]
 [2.000e+00       nan]
 [1.100e+01 2.049e+03]
 [      nan       nan]]

IndexHierarchy.via_T.__sub__(other)

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

InterfaceTranspose.__sub__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T - (0, 1, 1, -1)
[[   0. 1024.]
 [   0.   nan]
 [   9. 2047.]
 [  nan   nan]]

IndexHierarchy.via_T.__mul__(other)

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

InterfaceTranspose.__mul__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T * (0, 1, 1, -1)
[[0.000e+00 0.000e+00]
 [1.000e+00       nan]
 [1.000e+01 2.048e+03]
 [      nan       nan]]

IndexHierarchy.via_T.__truediv__(other)

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

InterfaceTranspose.__truediv__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T / (0, 1, 1, -1)
[[      nan       inf]
 [1.000e+00       nan]
 [1.000e+01 2.048e+03]
 [      nan       nan]]

IndexHierarchy.via_T.__floordiv__(other)

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

InterfaceTranspose.__floordiv__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T // (0, 1, 1, -1)
[[      nan       inf]
 [1.000e+00       nan]
 [1.000e+01 2.048e+03]
 [      nan       nan]]

IndexHierarchy.via_T.__mod__(other)

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

InterfaceTranspose.__mod__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T % (0, 1, 1, -1)
[[nan nan]
 [ 0. nan]
 [ 0.  0.]
 [nan nan]]

IndexHierarchy.via_T.__pow__(other)

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

InterfaceTranspose.__pow__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T ** (0, 1, 1, -1)
[[1.000e+00 1.000e+00]
 [1.000e+00       nan]
 [1.000e+01 2.048e+03]
 [      nan       nan]]

IndexHierarchy.via_T.__lshift__(other)

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

InterfaceTranspose.__lshift__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> s = sf.Series((0, -2, 3, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0
q        -2
r        3
s        1
<<U1>    <int64>
>>> ih.via_T << (1, 2, 1, 2)
TypeError("ufunc 'left_shift' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''")

IndexHierarchy.via_T.__rshift__(other)

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

InterfaceTranspose.__rshift__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> s = sf.Series((0, -2, 3, 1), index=('p', 'q', 'r', 's'))
>>> s
<Series>
<Index>
p        0
q        -2
r        3
s        1
<<U1>    <int64>
>>> ih.via_T >> (1, 2, 1, 2)
TypeError("ufunc 'right_shift' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''")

IndexHierarchy.via_T.__and__(other)

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

InterfaceTranspose.__and__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((False, True, True), (True, True, True), (False, True, False)), name=('x', 'y', 'z'))
>>> ih
<IndexHierarchy: ('x', 'y', 'z')>
False                             True   True
True                              True   True
False                             True   False
<bool>                            <bool> <bool>
>>> ih.via_T & (True, False, True)
[[False  True  True]
 [False False False]
 [False  True False]]

IndexHierarchy.via_T.__xor__(other)

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

InterfaceTranspose.__xor__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((False, True, True), (True, True, True), (False, True, False)), name=('x', 'y', 'z'))
>>> ih
<IndexHierarchy: ('x', 'y', 'z')>
False                             True   True
True                              True   True
False                             True   False
<bool>                            <bool> <bool>
>>> ih.via_T ^ (True, False, True)
[[ True False False]
 [ True  True  True]
 [ True False  True]]

IndexHierarchy.via_T.__or__(other)

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

InterfaceTranspose.__or__(other)[source]: Return self|value.

>>> ih = sf.IndexHierarchy.from_labels(((False, True, True), (True, True, True), (False, True, False)), name=('x', 'y', 'z'))
>>> ih
<IndexHierarchy: ('x', 'y', 'z')>
False                             True   True
True                              True   True
False                             True   False
<bool>                            <bool> <bool>
>>> ih.via_T | (True, False, True)
[[ True  True  True]
 [ True  True  True]
 [ True  True  True]]

IndexHierarchy.via_T.__lt__(other)

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

InterfaceTranspose.__lt__(other)[source]: Return self<value.

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T < (0, 1, 1, -1)
[[False False]
 [False False]
 [False False]
 [False False]]

IndexHierarchy.via_T.__le__(other)

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

InterfaceTranspose.__le__(other)[source]: Return self<=value.

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T <= (0, 1, 1, -1)
[[ True False]
 [ True False]
 [False False]
 [False False]]

IndexHierarchy.via_T.__eq__(other)

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

InterfaceTranspose.__eq__(other)[source]: Return self==value.

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T == (0, 1, 1, -1)
[[ True False]
 [ True False]
 [False False]
 [False False]]

IndexHierarchy.via_T.__ne__(other)

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

InterfaceTranspose.__ne__(other)[source]: Return self!=value.

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T != (0, 1, 1, -1)
[[False  True]
 [False  True]
 [ True  True]
 [ True  True]]

IndexHierarchy.via_T.__gt__(other)

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

InterfaceTranspose.__gt__(other)[source]: Return self>value.

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T > (0, 1, 1, -1)
[[False  True]
 [False False]
 [ True  True]
 [False False]]

IndexHierarchy.via_T.__ge__(other)

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

InterfaceTranspose.__ge__(other)[source]: Return self>=value.

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T >= (0, 1, 1, -1)
[[ True  True]
 [ True False]
 [ True  True]
 [False False]]

IndexHierarchy.via_T.__radd__(other)

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

InterfaceTranspose.__radd__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T + (0, 1, 1, -1)
[[0.000e+00 1.024e+03]
 [2.000e+00       nan]
 [1.100e+01 2.049e+03]
 [      nan       nan]]

IndexHierarchy.via_T.__rsub__(other)

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

InterfaceTranspose.__rsub__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T - (0, 1, 1, -1)
[[   0. 1024.]
 [   0.   nan]
 [   9. 2047.]
 [  nan   nan]]

IndexHierarchy.via_T.__rmul__(other)

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

InterfaceTranspose.__rmul__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T * (0, 1, 1, -1)
[[0.000e+00 0.000e+00]
 [1.000e+00       nan]
 [1.000e+01 2.048e+03]
 [      nan       nan]]

IndexHierarchy.via_T.__rtruediv__(other)

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

InterfaceTranspose.__rtruediv__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T / (0, 1, 1, -1)
[[      nan       inf]
 [1.000e+00       nan]
 [1.000e+01 2.048e+03]
 [      nan       nan]]

IndexHierarchy.via_T.__rfloordiv__(other)

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

InterfaceTranspose.__rfloordiv__(other)[source]

>>> ih = sf.IndexHierarchy.from_labels(((0, 1024), (1, np.nan), (10, 2048), (np.nan, np.nan)), name=('x', 'y'))
>>> ih
<IndexHierarchy: ('x', 'y')>
0.0                          1024.0
1.0                          nan
10.0                         2048.0
nan                          nan
<float64>                    <float64>
>>> ih.via_T // (0, 1, 1, -1)
[[      nan       inf]
 [1.000e+00       nan]
 [1.000e+01 2.048e+03]
 [      nan       nan]]