diff --git a/docs/user-guide/advanced/Pandas_API.ipynb b/docs/user-guide/advanced/Pandas_API.ipynb
index ee56ed9..c35d64b 100644
--- a/docs/user-guide/advanced/Pandas_API.ipynb
+++ b/docs/user-guide/advanced/Pandas_API.ipynb
@@ -687,6 +687,144 @@
     "tab.head(10)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "5e21bef1",
+   "metadata": {},
+   "source": [
+    "### Table.isna()\n",
+    "\n",
+    "```\n",
+    "Table.isna()\n",
+    "```\n",
+    "\n",
+    "Detects null values on a Table object.\n",
+    "\n",
+    "**Parameters:**\n",
+    "\n",
+    "\n",
+    "**Returns:**\n",
+    "\n",
+    "| Type               | Description                                                          |\n",
+    "| :----------------: | :------------------------------------------------------------------- |\n",
+    "| Table         | A Table with the same shape as the original but containing boolean values. 1b represents a null value was on its place and 0b represents the opposite. |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d8ff16e1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab.isna()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "47d20b00",
+   "metadata": {},
+   "source": [
+    "### Table.isnull()\n",
+    "\n",
+    "```\n",
+    "Table.isnull()\n",
+    "```\n",
+    "\n",
+    "Alias of Table.isna().\n",
+    "\n",
+    "Detects null values on a Table object.\n",
+    "\n",
+    "**Parameters:**\n",
+    "\n",
+    "\n",
+    "**Returns:**\n",
+    "\n",
+    "| Type               | Description                                                          |\n",
+    "| :----------------: | :------------------------------------------------------------------- |\n",
+    "| Table         | A Table with the same shape as the original but containing boolean values. 1b represents a null value was on its place and 0b represents the opposite. |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "400c209e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab.isnull()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fb3164d5",
+   "metadata": {},
+   "source": [
+    "### Table.notna()\n",
+    "\n",
+    "```\n",
+    "Table.notna()\n",
+    "```\n",
+    "\n",
+    "Boolean inverse of Table.isna().\n",
+    "\n",
+    "Detects non-null values on a Table object.\n",
+    "\n",
+    "**Parameters:**\n",
+    "\n",
+    "\n",
+    "**Returns:**\n",
+    "\n",
+    "| Type               | Description                                                          |\n",
+    "| :----------------: | :------------------------------------------------------------------- |\n",
+    "| Table         | A Table with the same shape as the original but containing boolean values. 1b represents a non null value was on its place and 0b represents the opposite. |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4206eec3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab.notna()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4e8e5c07",
+   "metadata": {},
+   "source": [
+    "### Table.notnull()\n",
+    "\n",
+    "```\n",
+    "Table.notna()\n",
+    "```\n",
+    "\n",
+    "Boolean inverse of Table.isnull(). Alias of Table.isna()\n",
+    "\n",
+    "Detects non-null values on a Table object.\n",
+    "\n",
+    "**Parameters:**\n",
+    "\n",
+    "\n",
+    "**Returns:**\n",
+    "\n",
+    "| Type               | Description                                                          |\n",
+    "| :----------------: | :------------------------------------------------------------------- |\n",
+    "| Table         | A Table with the same shape as the original but containing boolean values. 1b represents a non null value was on its place and 0b represents the opposite. |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3138d21a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab.notnull()"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "d1c370e4",
@@ -1743,7 +1881,7 @@
   },
   {
    "cell_type": "markdown",
-   "id": "71dab7ac",
+   "id": "d98b298c",
    "metadata": {},
    "source": [
     "### Table.min()\n",
@@ -1779,6 +1917,138 @@
     "tab.min()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "b52627d2",
+   "metadata": {},
+   "source": [
+    "### Table.idxmax()\n",
+    "\n",
+    "```\n",
+    "Table.idxmax(axis=0, skipna=True, numeric_only=False)\n",
+    "```\n",
+    "\n",
+    "Return index of first occurrence of maximum over requested axis.\n",
+    "\n",
+    "**Parameters:**\n",
+    "\n",
+    "| Name         | Type | Description                                                                      | Default |\n",
+    "| :----------: | :--: | :------------------------------------------------------------------------------- | :-----: |\n",
+    "| axis         | int  | The axis to calculate the idxmax across 0 is columns, 1 is rows.                | 0       |\n",
+    "| skipna       | bool | Ignore any null values along the axis.                                           | True    |\n",
+    "| numeric_only | bool | Only use columns of the table that are of a numeric data type.                   | False   |\n",
+    "\n",
+    "**Returns:**\n",
+    "\n",
+    "| Type               | Description                                                          |\n",
+    "| :----------------: | :------------------------------------------------------------------- |\n",
+    "| Dictionary         | A dictionary where the key represents the column name / row number and the values are the result of calling `idxmax` on that column / row. |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "838a07dd",
+   "metadata": {},
+   "source": [
+    "**Examples:**\n",
+    "\n",
+    "Calculate the idxmax across the columns of a table"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6c6d3384",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab.idxmax()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "30738846",
+   "metadata": {},
+   "source": [
+    "Calculate the idxmax across the rows of a table using only columns thar are of a numeric data type"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "edf9e128",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab.idxmax(axis=1, numeric_only=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fdb4114c-640a-41ac-a4e7-6c236e9d93ea",
+   "metadata": {},
+   "source": [
+    "### Table.idxmin()\n",
+    "\n",
+    "```\n",
+    "Table.idxmax(axis=0, skipna=True, numeric_only=False)\n",
+    "```\n",
+    "\n",
+    "Return index of first occurrence of minimum over requested axis.\n",
+    "\n",
+    "**Parameters:**\n",
+    "\n",
+    "| Name         | Type | Description                                                                      | Default |\n",
+    "| :----------: | :--: | :------------------------------------------------------------------------------- | :-----: |\n",
+    "| axis         | int  | The axis to calculate the idxmin across 0 is columns, 1 is rows.                | 0       |\n",
+    "| skipna       | bool | Ignore any null values along the axis.                                           | True    |\n",
+    "| numeric_only | bool | Only use columns of the table that are of a numeric data type.                   | False   |\n",
+    "\n",
+    "**Returns:**\n",
+    "\n",
+    "| Type               | Description                                                          |\n",
+    "| :----------------: | :------------------------------------------------------------------- |\n",
+    "| Dictionary         | A dictionary where the key represents the column name / row number and the values are the result of calling `idxmin` on that column / row. |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57053c36-932e-4805-916c-4cd5e3d33e82",
+   "metadata": {},
+   "source": [
+    "**Examples:**\n",
+    "\n",
+    "Calculate the idxmin across the columns of a table"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da7cbf8f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab.idxmin()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fb531e00",
+   "metadata": {},
+   "source": [
+    "Calculate the idxmin across the rows of a table using only columns thar are of a numeric data type"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9907226a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab.idxmin(axis=1, numeric_only=True)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "1bf3da2a",
@@ -2164,6 +2434,193 @@
     "tab.prod(numeric_only=True)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "fe565b65-fbf2-47ba-a26e-791d09fd4f55",
+   "metadata": {},
+   "source": [
+    "### Table.kurt()\n",
+    "\n",
+    "```\n",
+    "Table.kurt(axis=0, skipna=True, numeric_only=False)\n",
+    "```\n",
+    "\n",
+    "Return unbiased kurtosis over requested axis. Kurtosis obtained using Fisher’s definition of kurtosis (kurtosis of normal == 0.0). Normalized by N-1.\n",
+    "\n",
+    "\n",
+    "**Parameters:**\n",
+    "\n",
+    "| Name         | Type | Description                                                                      | Default |\n",
+    "| :----------: | :--: | :------------------------------------------------------------------------------- | :-----: |\n",
+    "| axis         | int  | Axis for the function to be applied on. 0 is columns, 1 is rows.                    | 0       |\n",
+    "| skipna       | bool | not yet implemented                                           | True    |\n",
+    "| numeric_only | bool | Only use columns of the table that are of a numeric data type.                   | False   |\n",
+    "\n",
+    "**Returns:**\n",
+    "\n",
+    "| Type       | Description                                                                              |\n",
+    "| :--------: | :--------------------------------------------------------------------------------------- |\n",
+    "| Dictionary | Map of columns and their yielded kurtosis values |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e6069cac-d260-4f80-9688-3d1ec273cd22",
+   "metadata": {},
+   "source": [
+    "**Examples:**\n",
+    "\n",
+    "Calculate the kurt across the columns of a table"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4219c826-a84b-4722-9847-372d3837acdb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab = kx.Table(data=\n",
+    "    {\n",
+    "        'a': [1, 2, 2, 4],\n",
+    "        'b': [1, 2, 6, 7],\n",
+    "        'c': [7, 8, 9, 10],\n",
+    "        'd': [7, 11, 14, 14]\n",
+    "    }\n",
+    ")\n",
+    "tab"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "437ab485-bf73-4209-b63e-aa0d1bfa5d58",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab.kurt()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ea3e1cf6-2304-4061-a846-1cbc0572ea9d",
+   "metadata": {},
+   "source": [
+    "Calculate the kurtosis across the rows of a table"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "63312e8b-76f0-46eb-b4d7-b2213561c86e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab.kurt(axis=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b248fef1",
+   "metadata": {},
+   "source": [
+    "### Table.sem()\n",
+    "\n",
+    "```\n",
+    "Table.sem(axis=0, skipna=True, numeric_only=False, ddof=0)\n",
+    "```\n",
+    "Return unbiased standard error of the mean over requested axis. Normalized by N-1 by default. This can be changed using the ddof argument\n",
+    "\n",
+    "**Parameters:**\n",
+    "\n",
+    "| Name         | Type | Description                                                                      | Default |\n",
+    "| :----------: | :--: | :------------------------------------------------------------------------------- | :-----: |\n",
+    "| axis         | int  | The axis to calculate the sum across 0 is columns, 1 is rows.                    | 0       |\n",
+    "| skipna       | bool | not yet implemented                                           | True    |\n",
+    "| numeric_only | bool | Only use columns of the table that are of a numeric data type.                   | False   |\n",
+    "| ddof    | int  | Delta Degrees of Freedom. The divisor used in calculations is N - ddof, where N represents the number of elements. | 1 |\n",
+    "\n",
+    "**Returns:**\n",
+    "\n",
+    "| Type               | Description                                                          |\n",
+    "| :----------------: | :------------------------------------------------------------------- |\n",
+    "| Dictionary         | The sem across each row / column with the key corresponding to the row number or column name. |"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71bd1d6f",
+   "metadata": {},
+   "source": [
+    "**Examples**\n",
+    "\n",
+    "Calculate the sem across the columns of a table"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "350c2b7c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab = kx.Table(data=\n",
+    "        {\n",
+    "            'a': [1, 2, 2, 4],\n",
+    "            'b': [1, 2, 6, 7],\n",
+    "            'c': [7, 8, 9, 10],\n",
+    "            'd': [7, 11, 14, 14],\n",
+    "        }\n",
+    "    )\n",
+    "tab"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b89307e9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab.sem()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6933f01f",
+   "metadata": {},
+   "source": [
+    "Calculate the sem across the rows of a table"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3edd3feb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab.sem(axis=1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae7afe5a",
+   "metadata": {},
+   "source": [
+    "Calculate sem accross columns with ddof=0:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "de626961",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tab.sem(ddof=0)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "c777923e",
diff --git a/src/pykx/pandas_api/pandas_meta.py b/src/pykx/pandas_api/pandas_meta.py
index 659a26b..243c6b7 100644
--- a/src/pykx/pandas_api/pandas_meta.py
+++ b/src/pykx/pandas_api/pandas_meta.py
@@ -67,7 +67,7 @@ def preparse_computations(tab, axis=0, skipna=True, numeric_only=False, bool_onl
         skipna,
         axis
     )
-    return (res, cols if axis == 0 else q.til(len(res)))
+    return (res, cols if axis == 0 else q.til(len(res)), cols)
 
 
 # The simple computation functions all return a tuple of the results and the col names the results
@@ -155,7 +155,33 @@ def mean(self, axis: int = 0, numeric_only: bool = False):
         )
 
     @api_return
+    def kurt(self, axis: int = 0, numeric_only: bool = False):
+        tab = self
+        if 'Keyed' in str(type(tab)):
+            tab = q.value(tab)
+        if numeric_only:
+            tab = _get_numeric_only_subtable(tab)
+
+        axis_keys = q('{[axis;tab] $[0~axis;cols;`$string til count @] tab}', axis, tab)
+
+        return q(
+            '''{[tab;axis;axis_keys]
+                tab:$[0~axis;(::);flip] value flip tab;
+                kurt:{[x]
+                      res: x - avg x;
+                      n: count x;
+                      m2: sum rsq: res xexp 2;
+                      m4: sum rsq xexp 2;
+                      adj: 3 * xexp[n - 1;2] % (n - 2) * (n - 3);
+                      num: n * (n + 1) * (n - 1) * m4;
+                      den: (n - 2) * (n - 3) * m2 xexp 2;
+                      (num % den) - adj};
+                axis_keys!kurt each tab}
+            ''', tab, axis, axis_keys
+        )
+
     def std(self, axis: int = 0, ddof: int = 1, numeric_only: bool = False):
+
         tab = self
         if 'Keyed' in str(type(tab)):
             tab = q.value(tab)
@@ -198,7 +224,7 @@ def median(self, axis: int = 0, numeric_only: bool = False):
 
     @convert_result
     def skew(self, axis=0, skipna=True, numeric_only=False):
-        res, cols = preparse_computations(self, axis, skipna, numeric_only)
+        res, cols, _ = preparse_computations(self, axis, skipna, numeric_only)
         return (q(
             '''{[row]
                 m:{(sum (x - avg x) xexp y) % count x};
@@ -236,6 +262,27 @@ def mode(self, axis: int = 0, numeric_only: bool = False, dropna: bool = True):
             tab
         )
 
+    @api_return
+    def sem(self, axis: int = 0, ddof: int = 1, numeric_only: bool = False):
+        tab = self
+        if 'Keyed' in str(type(tab)):
+            tab = q.value(tab)
+        if numeric_only:
+            tab = _get_numeric_only_subtable(tab)
+
+        axis_keys = q('{[axis;tab] $[0~axis;cols;`$string til count @] tab}', axis, tab)
+
+        if ddof == len(tab):
+            return q('{x!count[x]#0n}', axis_keys)
+
+        return q(
+            '''{[tab;axis;ddof;axis_keys]
+                tab:$[0~axis;(::);flip] value flip tab;
+                d:{dev[x] % sqrt count[x] - y}[;ddof];
+                axis_keys!d each tab}
+            ''', tab, axis, ddof, axis_keys
+        )
+
     @api_return
     def abs(self, numeric_only=False):
         tab = self
@@ -245,17 +292,17 @@ def abs(self, numeric_only=False):
 
     @convert_result
     def all(self, axis=0, bool_only=False, skipna=True):
-        res, cols = preparse_computations(self, axis, skipna, bool_only=bool_only)
+        res, cols, _ = preparse_computations(self, axis, skipna, bool_only=bool_only)
         return (q('{"b"$x}', [all(x) for x in res]), cols)
 
     @convert_result
     def any(self, axis=0, bool_only=False, skipna=True):
-        res, cols = preparse_computations(self, axis, skipna, bool_only=bool_only)
+        res, cols, _ = preparse_computations(self, axis, skipna, bool_only=bool_only)
         return (q('{"b"$x}', [any(x) for x in res]), cols)
 
     @convert_result
     def max(self, axis=0, skipna=True, numeric_only=False):
-        res, cols = preparse_computations(self, axis, skipna, numeric_only)
+        res, cols, _ = preparse_computations(self, axis, skipna, numeric_only)
         return (q(
             '{[row] {$[11h=type x; {[x1; y1] $[x1 > y1; x1; y1]} over x; max x]} each row}',
             res
@@ -263,15 +310,39 @@ def max(self, axis=0, skipna=True, numeric_only=False):
 
     @convert_result
     def min(self, axis=0, skipna=True, numeric_only=False):
-        res, cols = preparse_computations(self, axis, skipna, numeric_only)
+        res, cols, _ = preparse_computations(self, axis, skipna, numeric_only)
         return (q(
             '{[row] {$[11h=type x; {[x1; y1] $[x1 < y1; x1; y1]} over x; min x]} each row}',
             res
         ), cols)
 
+    @convert_result
+    def idxmax(self, axis=0, skipna=True, numeric_only=False):
+        tab = self
+        axis = q('{$[11h~type x; `index`columns?x; x]}', axis)
+        res, cols, ix = preparse_computations(tab, axis, skipna, numeric_only)
+        return (q(
+            '''{[row;tab;axis]
+                row:{$[11h~type x; {[x1; y1] $[x1 > y1; x1; y1]} over x; max x]} each row;
+                m:$[0~axis; (::); flip] value flip tab;
+                $[0~axis; (::); cols tab] m {$[abs type y;x]?y}' row}
+            ''', res, tab[ix], axis), cols)
+
+    @convert_result
+    def idxmin(self, axis=0, skipna=True, numeric_only=False):
+        tab = self
+        axis = q('{$[11h~type x; `index`columns?x; x]}', axis)
+        res, cols, ix = preparse_computations(tab, axis, skipna, numeric_only)
+        return (q(
+            '''{[row;tab;axis]
+                row:{$[11h~type x; {[x1; y1] $[x1 < y1; x1; y1]} over x; min x]} each row;
+                m:$[0~axis; (::); flip] value flip tab;
+                $[0~axis; (::); cols tab] m {$[abs type y;x]?y}' row}
+            ''', res, tab[ix], axis), cols)
+
     @convert_result
     def prod(self, axis=0, skipna=True, numeric_only=False, min_count=0):
-        res, cols = preparse_computations(self, axis, skipna, numeric_only)
+        res, cols, _ = preparse_computations(self, axis, skipna, numeric_only)
         return (q(
             '{[row; minc] {$[y > 0; $[y>count[x]; 0N; prd x]; prd x]}[;minc] each row}',
             res,
@@ -280,7 +351,7 @@ def prod(self, axis=0, skipna=True, numeric_only=False, min_count=0):
 
     @convert_result
     def sum(self, axis=0, skipna=True, numeric_only=False, min_count=0):
-        res, cols = preparse_computations(self, axis, skipna, numeric_only)
+        res, cols, _ = preparse_computations(self, axis, skipna, numeric_only)
         return (q(
             '{[row; minc]'
             '{$[y > 0;'
@@ -347,5 +418,21 @@ def agg(self, func, axis=0, *args, **kwargs): # noqa: C901
 
     @convert_result
     def count(self, axis=0, numeric_only=False):
-        res, cols = preparse_computations(self, axis, True, numeric_only)
+        res, cols, _ = preparse_computations(self, axis, True, numeric_only)
         return (q('count each', res), cols)
+
+    @api_return
+    def isna(self):
+        return q.null(self)
+
+    @api_return
+    def isnull(self):
+        return self.isna()
+
+    @api_return
+    def notna(self):
+        return q('not', self.isna())
+
+    @api_return
+    def notnull(self):
+        return self.notna()
diff --git a/tests/test_pandas_api.py b/tests/test_pandas_api.py
index 6cae5a8..80dfb05 100644
--- a/tests/test_pandas_api.py
+++ b/tests/test_pandas_api.py
@@ -1554,6 +1554,86 @@ def test_df_sample(kx, q):
         t.sample(ignore_index=True)
 
 
+def test_sem(kx, q):
+    df = pd.DataFrame(
+        {
+            'a': [1, 2, 2, 4],
+            'b': [1, 2, 6, 7],
+            'c': [7, 8, 9, 10],
+            'd': [7, 11, 14, 14]
+        }
+    )
+    precision = 1e-16
+    tab = kx.toq(df)
+    p_m = df.sem()
+    q_m = tab.sem()
+    assert all([p_m[c] == pytest.approx(q_m[c].py(),  precision)
+                for c in q.key(q_m).py()])
+
+    p_m = df.sem(axis=1)
+    q_m = tab.sem(axis=1)
+    assert all([p_m[c] == pytest.approx(q_m[q('{`$string x}', c)].py(), precision)
+                for c in range(len(q.cols(tab)))])
+
+    p_m = df.sem(ddof=0)
+    q_m = tab.sem(ddof=0)
+    assert all([p_m[c] == pytest.approx(q_m[c].py(),  precision)
+                for c in q.key(q_m).py()])
+
+    p_m = df.sem(ddof=4)
+    q_m = tab.sem(ddof=4)
+    assert all([np.isnan(p_m[c]) & np.isnan(q_m[c].py())
+                for c in q.key(q_m).py()])
+
+    q['tab'] = kx.toq(df)
+    tab = q('1!`idx xcols update idx: til count tab from tab')
+    p_m = df.sem()
+    q_m = tab.sem()
+    assert all([p_m[c] == pytest.approx(q_m[c].py(), precision)
+                for c in q.key(q_m).py()])
+
+    p_m = df.sem(axis=1)
+    q_m = tab.sem(axis=1)
+    assert all([p_m[c] == pytest.approx(q_m[q('{`$string x}', c)].py(), precision)
+                for c in range(len(q.cols(tab)) - 1)])
+
+    df = pd.DataFrame(
+        {
+            'a': [1, 2, 2, 4],
+            'b': [1, 2, 6, 7],
+            'c': [7, 8, 9, 10],
+            'd': ['foo', 'bar', 'baz', 'qux']
+        }
+    )
+    tab = kx.toq(df)
+    p_m = df.sem(numeric_only=True)
+    q_m = tab.sem(numeric_only=True)
+    assert all([p_m[c] == pytest.approx(q_m[c].py(), precision)
+                for c in q.key(q_m).py()])
+
+    p_m = df.sem(axis=1, numeric_only=True)
+    q_m = tab.sem(axis=1, numeric_only=True)
+    assert all([p_m[c] == pytest.approx(q_m[q('{`$string x}', c)].py(), precision)
+                for c in range(len(q.cols(tab)))])
+
+    with pytest.raises(kx.QError):
+        q_m = tab.sem()
+    with pytest.raises(kx.QError):
+        q_m = tab.sem(axis=1)
+
+    df = pd.DataFrame({'a': [1]})
+    tab = kx.toq(df)
+    p_m = df.sem()
+    q_m = tab.sem()
+    assert all([np.isnan(p_m[c]) & np.isnan(q_m[c].py())
+                for c in q.key(q_m).py()])
+
+    p_m = df.sem(ddof=0)
+    q_m = tab.sem(ddof=0)
+    assert all([p_m[c] == pytest.approx(q_m[c].py(), precision)
+                for c in q.key(q_m).py()])
+
+
 def test_mean(kx, q):
     df = pd.DataFrame(
         {
@@ -1608,6 +1688,79 @@ def test_mean(kx, q):
         q_m = tab.mean(axis=1)
 
 
+def test_kurt(kx, q):
+    df = pd.DataFrame(
+        {
+            'a': [1, 2, 2, 4],
+            'b': [1, 2, 6, 7],
+            'c': [7, 8, 9, 10],
+            'd': [7, 11, 14, 14]
+        }
+    )
+    tab = kx.toq(df)
+    p_m = df.kurt()
+    q_m = tab.kurt()
+    for c in q.key(q_m).py():
+        assert p_m[c] == q_m[c].py()
+    p_m = df.kurt(axis=1)
+    q_m = tab.kurt(axis=1)
+    for c in range(len(q.cols(tab))):
+        assert p_m[c] == q_m[q('{`$string x}', c)].py()
+
+    q['tab'] = kx.toq(df)
+    tab = q('1!`idx xcols update idx: til count tab from tab')
+    p_m = df.kurt()
+    q_m = tab.kurt()
+    for c in q.key(q_m).py():
+        assert p_m[c] == q_m[c].py()
+    p_m = df.kurt(axis=1)
+    q_m = tab.kurt(axis=1)
+    for c in range(len(q.cols(tab)) - 1):
+        assert p_m[c] == q_m[q('{`$string x}', c)].py()
+
+    df = pd.DataFrame(
+        {
+            'a': [1, 2, 2, 4],
+            'b': [1, 2, 6, 7],
+            'c': [7, 8, 9, 10],
+            'd': ['foo', 'bar', 'baz', 'qux']
+        }
+    )
+    tab = kx.toq(df)
+    p_m = df.kurt(numeric_only=True)
+    q_m = tab.kurt(numeric_only=True)
+    for c in q.key(q_m).py():
+        assert p_m[c] == q_m[c].py()
+    p_m = df.kurt(axis=1, numeric_only=True)
+    q_m = tab.kurt(axis=1, numeric_only=True)
+    for c in range(len(q.cols(tab))):
+        assert np.isnan(p_m[c]) & np.isnan(q_m[q('{`$string x}', c)].py())
+
+    df = pd.DataFrame(
+        {
+            'a': [1, 2, 2, 4],
+            'b': [1, 2, 6, 7],
+            'c': [7, 8, 9, 10],
+            'd': [11, 12, 13, 14],
+            'e': ['foo', 'bar', 'baz', 'qux']
+        }
+    )
+    tab = kx.toq(df)
+    p_m = df.kurt(numeric_only=True)
+    q_m = tab.kurt(numeric_only=True)
+    for c in q.key(q_m).py():
+        assert p_m[c] == q_m[c].py()
+    p_m = df.kurt(axis=1, numeric_only=True)
+    q_m = tab.kurt(axis=1, numeric_only=True)
+    for c in range(len(q.cols(tab)) - 1):
+        assert p_m[c] == q_m[q('{`$string x}', c)].py()
+
+    with pytest.raises(kx.QError):
+        q_m = tab.kurt()
+    with pytest.raises(kx.QError):
+        q_m = tab.kurt(axis=1)
+
+
 def test_median(kx, q):
     df = pd.DataFrame(
         {
@@ -1885,6 +2038,52 @@ def test_pandas_max(q):
     assert float(pmax['ints']) == qmax['ints']
 
 
+def test_pandas_idxmax(q):
+    tab = q('([] sym: 100?`foo`bar`baz`qux; price: 250.0f - 100?500.0f; ints: 100 - 100?200)')
+    df = tab.pd()
+
+    p_m = df.idxmax()
+    q_m = tab.idxmax()
+    for c in q.key(q_m).py():
+        assert p_m[c] == q_m[c].py()
+
+    q_m = tab.idxmax(axis=1, numeric_only=True, skipna=True)
+    p_m = df.idxmax(axis=1, numeric_only=True, skipna=True)
+    for c in q.key(q_m).py():
+        assert p_m[c] == q_m[c].py()
+
+    tab = q('([]price: 250.0f - 100?500.0f; ints: 100 - 100?200)')
+    df = tab.pd()
+
+    q_m = tab.idxmax(axis=1)
+    p_m = df.idxmax(axis=1)
+    for c in q.key(q_m).py():
+        assert p_m[c] == q_m[c].py()
+
+
+def test_pandas_idxmin(q):
+    tab = q('([] sym: 100?`foo`bar`baz`qux; price: 250.0f - 100?500.0f; ints: 100 - 100?200)')
+    df = tab.pd()
+
+    p_m = df.idxmin()
+    q_m = tab.idxmin()
+    for c in q.key(q_m).py():
+        assert p_m[c] == q_m[c].py()
+
+    q_m = tab.idxmin(axis=1, numeric_only=True, skipna=True)
+    p_m = df.idxmin(axis=1, numeric_only=True, skipna=True)
+    for c in q.key(q_m).py():
+        assert p_m[c] == q_m[c].py()
+
+    tab = q('([]price: 250.0f - 100?500.0f; ints: 100 - 100?200)')
+    df = tab.pd()
+
+    q_m = tab.idxmin(axis=1)
+    p_m = df.idxmin(axis=1)
+    for c in q.key(q_m).py():
+        assert p_m[c] == q_m[c].py()
+
+
 def test_pandas_all(q):
     tab = q(
         '([] sym: 100?`foo`bar`baz`qux; price: 250.0f - 100?500.0f; ints: 100 - 100?200;'
@@ -2109,6 +2308,37 @@ def test_keyed_loc_fixes(q):
         mkt['k1']
 
 
+def test_isnull(q):
+    tab = q('''([]
+        g:1#0Ng;    h:1#0Nh;    i1:1#0Ni; j:1#0Nj;
+        e:1#0Ne;    f:1#0Nf;    s:1#`  ;  p:1#0Np;
+        m:1#0Nm;    d:1#0Nd;    n:1#0Nn;  u:1#0Nu;
+        v:1#0Nv;    t:1#0Nt;    c:1#" ";
+        g2:1?0Ng;   h2:1?0Wh;   i2:1?10i; j2:1?10j;
+        e2:1?10e;   f2:1?10f;   s2:1#`foo;p2:1?10p;
+        m2:1?"m"$10;d2:1?"d"$10;n2:1?10n; u2:1?10u;
+        v2:1?10v;   t2:1?10t;   c2:1?" ")
+        ''')
+
+    cols = ["g", "h", "i1", "j",
+            "e", "f", "s", "p",
+            "m", "d", "n", "u",
+            "v", "t", "c",
+            "g2", "h2", "i2", "j2",
+            "e2", "f2", "s2", "p2",
+            "m2", "d2", "n2", "u2",
+            "v2", "t2", "c2"]
+
+    expected = pd.DataFrame.from_dict({c: [True] if i < 15 else [False]
+                                       for i, c in enumerate(cols)})
+    expected_inv = ~expected
+
+    pd.testing.assert_frame_equal(tab.isna().pd(), expected)
+    pd.testing.assert_frame_equal(tab.isnull().pd(), expected)
+    pd.testing.assert_frame_equal(tab.notna().pd(), expected_inv)
+    pd.testing.assert_frame_equal(tab.notnull().pd(), expected_inv)
+
+
 def test_pandas_count(q):
     tab = q('([] k1: 0n 2 0n 2 0n ; k2: (`a;`;`b;`;`c))')
     df = tab.pd()
@@ -2264,3 +2494,4 @@ def test_std(kx, q):
         q_m = tab.std()
     with pytest.raises(kx.QError):
         q_m = tab.std(axis=1)
+