Detail: FrameGO: Operator Binary

Overview: FrameGO: Operator Binary

FrameGO.__add__(other)
>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> f1 + 8
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            18      16      9
q            6       5       8
r            8       16      17
s            8       8       20
<<U1>        <int64> <int64> <int64>
>>> f1 + f2
<FrameGO>
<IndexGO> a         b         c         <<U1>
<Index>
p         12.0      11.0      nan
q         7.0       5.0       nan
r         nan       nan       nan
s         nan       nan       nan
<<U1>     <float64> <float64> <float64>
FrameGO.__and__(other)
>>> f = sf.FrameGO.from_fields(((False, True, True), (True, True, False)), columns=('a', 'b'), index=('p', 'q', 'r'), name='x')
>>> f
<FrameGO: x>
<IndexGO>    a      b      <<U1>
<Index>
p            False  True
q            True   True
r            True   False
<<U1>        <bool> <bool>
>>> f & True
<FrameGO: x>
<IndexGO>    a      b      <<U1>
<Index>
p            False  True
q            True   True
r            True   False
<<U1>        <bool> <bool>
>>> f & (True, False)
<FrameGO>
<IndexGO> a      b      <<U1>
<Index>
p         False  False
q         True   False
r         True   False
<<U1>     <bool> <bool>
FrameGO.__eq__(other)

Return self==value.

>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> f1 == 8
<FrameGO: x>
<IndexGO>    a      b      c      <<U1>
<Index>
p            False  True   False
q            False  False  False
r            False  True   False
s            False  False  False
<<U1>        <bool> <bool> <bool>
>>> f1 == f2
<FrameGO>
<IndexGO> a      b      c      <<U1>
<Index>
p         False  False  False
q         False  False  False
r         False  False  False
s         False  False  False
<<U1>     <bool> <bool> <bool>
FrameGO.__floordiv__(other)
>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> f1 // 8
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            1       1       0
q            -1      -1      0
r            0       1       1
s            0       0       1
<<U1>        <int64> <int64> <int64>
>>> f1 // f2
<FrameGO>
<IndexGO> a         b         c         <<U1>
<Index>
p         5.0       2.0       nan
q         -1.0      -1.0      nan
r         nan       nan       nan
s         nan       nan       nan
<<U1>     <float64> <float64> <float64>
FrameGO.__ge__(other)

Return self>=value.

>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> f1 >= 8
<FrameGO: x>
<IndexGO>    a      b      c      <<U1>
<Index>
p            True   True   False
q            False  False  False
r            False  True   True
s            False  False  True
<<U1>        <bool> <bool> <bool>
>>> f1 >= f2
<FrameGO>
<IndexGO> a      b      c      <<U1>
<Index>
p         True   True   False
q         False  False  False
r         False  False  False
s         False  False  False
<<U1>     <bool> <bool> <bool>
FrameGO.__gt__(other)

Return self>value.

>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> f1 > 8
<FrameGO: x>
<IndexGO>    a      b      c      <<U1>
<Index>
p            True   False  False
q            False  False  False
r            False  False  True
s            False  False  True
<<U1>        <bool> <bool> <bool>
>>> f1 > f2
<FrameGO>
<IndexGO> a      b      c      <<U1>
<Index>
p         True   True   False
q         False  False  False
r         False  False  False
s         False  False  False
<<U1>     <bool> <bool> <bool>
FrameGO.__le__(other)

Return self<=value.

>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> f1 <= 8
<FrameGO: x>
<IndexGO>    a      b      c      <<U1>
<Index>
p            False  True   True
q            True   True   True
r            True   True   False
s            True   True   False
<<U1>        <bool> <bool> <bool>
>>> f1 <= f2
<FrameGO>
<IndexGO> a      b      c      <<U1>
<Index>
p         False  False  False
q         True   True   False
r         False  False  False
s         False  False  False
<<U1>     <bool> <bool> <bool>
FrameGO.__lt__(other)

Return self<value.

>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> f1 < 8
<FrameGO: x>
<IndexGO>    a      b      c      <<U1>
<Index>
p            False  False  True
q            True   True   True
r            True   False  False
s            True   True   False
<<U1>        <bool> <bool> <bool>
>>> f1 < f2
<FrameGO>
<IndexGO> a      b      c      <<U1>
<Index>
p         False  False  False
q         True   True   False
r         False  False  False
s         False  False  False
<<U1>     <bool> <bool> <bool>
FrameGO.__matmul__(other)
>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            1       2       1
q            2       1       0
r            0       2       2
s            0       0       1
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((3, 0, 20), (2, 0, 12)), index=('a', 'b', 'c'), columns=('x', 'y'), name='y')
>>> f2
<FrameGO: y>
<IndexGO>    x       y       <<U1>
<Index>
a            3       2
b            0       0
c            20      12
<<U1>        <int64> <int64>
>>> f1 @ f2
<FrameGO>
<IndexGO> x       y       <<U1>
<Index>
p         23      14
q         6       4
r         40      24
s         20      12
<<U1>     <int64> <int64>
FrameGO.__mod__(other)
>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> f1 % 8
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            2       0       1
q            6       5       0
r            0       0       1
s            0       0       4
<<U1>        <int64> <int64> <int64>
>>> f1 % f2
<FrameGO>
<IndexGO> a         b         c         <<U1>
<Index>
p         0.0       2.0       nan
q         7.0       5.0       nan
r         nan       nan       nan
s         nan       nan       nan
<<U1>     <float64> <float64> <float64>
FrameGO.__mul__(other)
>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> f1 * 8
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            80      64      8
q            -16     -24     0
r            0       64      72
s            0       0       96
<<U1>        <int64> <int64> <int64>
>>> f1 * f2
<FrameGO>
<IndexGO> a         b         c         <<U1>
<Index>
p         20.0      24.0      nan
q         -18.0     -24.0     nan
r         nan       nan       nan
s         nan       nan       nan
<<U1>     <float64> <float64> <float64>
FrameGO.__ne__(other)

Return self!=value.

>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> f1 != 8
<FrameGO: x>
<IndexGO>    a      b      c      <<U1>
<Index>
p            True   False  True
q            True   True   True
r            True   False  True
s            True   True   True
<<U1>        <bool> <bool> <bool>
>>> f1 != f2
<FrameGO>
<IndexGO> a      b      c      <<U1>
<Index>
p         True   True   True
q         True   True   True
r         True   True   True
s         True   True   True
<<U1>     <bool> <bool> <bool>
FrameGO.__or__(other)

Return self|value.

>>> f = sf.FrameGO.from_fields(((False, True, True), (True, True, False)), columns=('a', 'b'), index=('p', 'q', 'r'), name='x')
>>> f
<FrameGO: x>
<IndexGO>    a      b      <<U1>
<Index>
p            False  True
q            True   True
r            True   False
<<U1>        <bool> <bool>
>>> f | True
<FrameGO: x>
<IndexGO>    a      b      <<U1>
<Index>
p            True   True
q            True   True
r            True   True
<<U1>        <bool> <bool>
>>> f | (True, False)
<FrameGO>
<IndexGO> a      b      <<U1>
<Index>
p         True   True
q         True   True
r         True   False
<<U1>     <bool> <bool>
FrameGO.__pow__(other)
>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> f1 ** 8
<FrameGO: x>
<IndexGO>    a         b        c         <<U1>
<Index>
p            100000000 16777216 1
q            256       6561     0
r            0         16777216 43046721
s            0         0        429981696
<<U1>        <int64>   <int64>  <int64>
>>> f1 ** f2
<FrameGO>
<IndexGO> a         b         c         <<U1>
<Index>
p         100.0     512.0     1.0
q         -512.0    6561.0    nan
r         nan       nan       nan
s         nan       nan       nan
<<U1>     <float64> <float64> <float64>
FrameGO.__radd__(other)
>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> 8 + f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            18      16      9
q            6       5       8
r            8       16      17
s            8       8       20
<<U1>        <int64> <int64> <int64>
FrameGO.__rfloordiv__(other)
>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> 8 // f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            0       1       8
q            -4      -3      0
r            0       1       0
s            0       0       0
<<U1>        <int64> <int64> <int64>
FrameGO.__rmatmul__(other)
>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            1       2       1
q            2       1       0
r            0       2       2
s            0       0       1
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((3, 0, 20), (2, 0, 12)), index=('a', 'b', 'c'), columns=('x', 'y'), name='y')
>>> f2
<FrameGO: y>
<IndexGO>    x       y       <<U1>
<Index>
a            3       2
b            0       0
c            20      12
<<U1>        <int64> <int64>
>>> f1 @ f2
<FrameGO>
<IndexGO> x       y       <<U1>
<Index>
p         23      14
q         6       4
r         40      24
s         20      12
<<U1>     <int64> <int64>
FrameGO.__rmul__(other)
>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> 8 * f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            80      64      8
q            -16     -24     0
r            0       64      72
s            0       0       96
<<U1>        <int64> <int64> <int64>
FrameGO.__rshift__(other)
>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f1 >> 1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            5       4       0
q            -1      -2      0
r            0       4       4
s            0       0       6
<<U1>        <int64> <int64> <int64>
FrameGO.__rsub__(other)
>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> 8 - f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            -2      0       7
q            10      11      8
r            8       0       -1
s            8       8       -4
<<U1>        <int64> <int64> <int64>
FrameGO.__rtruediv__(other)
>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> 8 / f1
<FrameGO: x>
<IndexGO>    a         b                   c                  <<U1>
<Index>
p            0.8       1.0                 8.0
q            -4.0      -2.6666666666666665 inf
r            inf       1.0                 0.8888888888888888
s            inf       inf                 0.6666666666666666
<<U1>        <float64> <float64>           <float64>
FrameGO.__sub__(other)
>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> f1 - 8
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            2       0       -7
q            -10     -11     -8
r            -8      0       1
s            -8      -8      4
<<U1>        <int64> <int64> <int64>
>>> f1 - f2
<FrameGO>
<IndexGO> a         b         c         <<U1>
<Index>
p         8.0       5.0       nan
q         -11.0     -11.0     nan
r         nan       nan       nan
s         nan       nan       nan
<<U1>     <float64> <float64> <float64>
FrameGO.__truediv__(other)
>>> f1 = sf.FrameGO.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')
>>> f1
<FrameGO: x>
<IndexGO>    a       b       c       <<U1>
<Index>
p            10      8       1
q            -2      -3      0
r            0       8       9
s            0       0       12
<<U1>        <int64> <int64> <int64>
>>> f2 = sf.FrameGO.from_fields(((2, 9), (3, 8)), columns=('a', 'b'), index=('p', 'q'), name='x')
>>> f2
<FrameGO: x>
<IndexGO>    a       b       <<U1>
<Index>
p            2       3
q            9       8
<<U1>        <int64> <int64>
>>> f1 / 8
<FrameGO: x>
<IndexGO>    a         b         c         <<U1>
<Index>
p            1.25      1.0       0.125
q            -0.25     -0.375    0.0
r            0.0       1.0       1.125
s            0.0       0.0       1.5
<<U1>        <float64> <float64> <float64>
>>> f1 / f2
<FrameGO>
<IndexGO> a                   b                  c         <<U1>
<Index>
p         5.0                 2.6666666666666665 nan
q         -0.2222222222222222 -0.375             nan
r         nan                 nan                nan
s         nan                 nan                nan
<<U1>     <float64>           <float64>          <float64>
FrameGO.__xor__(other)
>>> f = sf.FrameGO.from_fields(((False, True, True), (True, True, False)), columns=('a', 'b'), index=('p', 'q', 'r'), name='x')
>>> f
<FrameGO: x>
<IndexGO>    a      b      <<U1>
<Index>
p            False  True
q            True   True
r            True   False
<<U1>        <bool> <bool>
>>> f ^ True
<FrameGO: x>
<IndexGO>    a      b      <<U1>
<Index>
p            True   False
q            False  False
r            False  True
<<U1>        <bool> <bool>
>>> f ^ (True, False)
<FrameGO>
<IndexGO> a      b      <<U1>
<Index>
p         True   True
q         False  True
r         False  False
<<U1>     <bool> <bool>

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