Add iat and at methods to Series

Author: risenW

src/danfojs-base/core/frame.ts

@@ -3336,7 +3336,7 @@ export default class DataFrame extends NDframe implements DataFrameInterface {
     /**
      * Access a single value for a row/column pair by integer position.
      * Similar to {@link iloc}, in that both provide integer-based lookups. 
-     * Use iat if you only need to get or set a single value in a DataFrame or Series.
+     * Use iat if you only need to get or set a single value in a DataFrame.
      * @param row Row index of the value to access.
      * @param column Column index of the value to access.
      * @example
@@ -3347,7 +3347,7 @@ export default class DataFrame extends NDframe implements DataFrameInterface {
      * df.iat(1, 0) // 3
      * ```
     */
-    iat(row: number, column: number): string | number | boolean {
+    iat(row: number, column: number): string | number | boolean | undefined {
         if(typeof row === 'string' || typeof column === 'string') {
             throw new Error('ParamError: row and column index must be an integer. Use .at to get a row or column by label.')
         }
@@ -3358,7 +3358,7 @@ export default class DataFrame extends NDframe implements DataFrameInterface {
     /**
      * Access a single value for a row/column label pair.
      * Similar to {@link loc}, in that both provide label-based lookups. 
-     * Use at if you only need to get or set a single value in a DataFrame or Series.
+     * Use at if you only need to get or set a single value in a DataFrame.
      * @param row Row index of the value to access.
      * @param column Column label of the value to access.
      * @example
@@ -3369,7 +3369,7 @@ export default class DataFrame extends NDframe implements DataFrameInterface {
      * df.at(1, 'B') // 4
      * ```
     */
-    at(row: string | number, column: string): string | number | boolean {
+    at(row: string | number, column: string): string | number | boolean | undefined {
         if(typeof column !== 'string') {
             throw new Error('ParamError: column index must be a string. Use .iat to get a row or column by index.')
         }

src/danfojs-base/core/series.ts

@@ -2239,4 +2239,44 @@ export default class Series extends NDframe implements SeriesInterface {
             return toExcelNode(this, options as ExcelOutputOptionsNode)
         }
     }
+
+    /**
+     * Access a single value for a row index.
+     * Similar to iloc, in that both provide index-based lookups. 
+     * Use iat if you only need to get or set a single value in a Series.
+     * @param row Row index of the value to access.
+     * @example
+     * ```
+     * const sf = new Series([1, 2, 3, 4, 5])
+     * sf.iat(0) //returns 1
+     * sf.iat(1) //returns 2
+     * sf.iat(2) //returns 3
+     * ```
+    */
+    iat(row: number): number | string | boolean | undefined {
+        if(typeof row === 'string') {
+            throw new Error('ParamError: row index must be an integer. Use .at to get a row by label.')
+        }
+        return (this.values as ArrayType1D)[row];
+    }
+
+    /**
+     * Access a single value for a row label.
+     * Similar to loc, in that both provide label-based lookups.
+     * Use at if you only need to get or set a single value in a Series.
+     * @param row Row label of the value to access.
+     * @example
+     * ```
+     * const sf = new Series([1, 2, 3, 4, 5, 6], { index: ['A', 'B', 'C', 'D', 'E', 'F'] })
+     * sf.at('A') //returns 1
+     * sf.at('B') //returns 2
+     * sf.at('C') //returns 3
+     * ```
+    */
+    at(row: string): number | string | boolean | undefined {
+        if(typeof row !== 'string') {
+            throw new Error('ParamError: row index must be a string. Use .iat to get a row by index.')
+        }
+        return (this.values as ArrayType1D)[this.index.indexOf(row)];
+    }
 }

src/danfojs-base/shared/types.ts

@@ -184,6 +184,8 @@ export interface SeriesInterface extends NDframeInterface {
     toCSV(options?: CsvOutputOptionsBrowser): string | void
     toJSON(options?: JsonOutputOptionsBrowser): object | void
     toExcel(options?: ExcelOutputOptionsBrowser): void
+    iat(index: number): number | string | boolean | undefined 
+    at(index: string | number): number | string | boolean | undefined 
 }
 
 //Start of DataFrame class types
@@ -327,8 +329,8 @@ export interface DataFrameInterface extends NDframeInterface {
     toCSV(options?: CsvOutputOptionsBrowser): string | void
     toJSON(options?: JsonOutputOptionsBrowser): object | void
     toExcel(options?: ExcelOutputOptionsBrowser): void
-    iat(row: number, column: number): string | number | boolean
-    at(row: string | number, column: string): string | number | boolean
+    iat(row: number, column: number): number | string | boolean | undefined 
+    at(row: string | number, column: string): number | string | boolean | undefined 
 }
 
 export interface DateTime {

src/danfojs-browser/tests/core/series.test.js

@@ -1583,4 +1583,58 @@ describe("Series Functions", () => {
     });
 
   });
+
+  describe("iat", function () {
+    it("iat works on Series", function () {
+      const data = [ 1, 2, 3, 4 ];
+      const index = [ "a", "b", "c", "d" ];
+      const df = new dfd.Series(data, { index });
+      assert.equal(df.iat(0), 1);
+      assert.equal(df.iat(1), 2);
+      assert.equal(df.iat(2), 3);
+    });
+    it("iat can return undefined", function () {
+      const data = [ 1, undefined, null, NaN ];
+      const df = new dfd.Series(data);
+      assert.equal(df.iat(1), undefined);
+      assert.equal(df.iat(2), null);
+      /* @ts-ignore */
+      assert.equal(isNaN(df.iat(3)), true);
+    });
+    it("throws error on string indices", function () {
+      const data = [ 1, 2, 3, 4 ];
+      const index = [ "a", "b", "c", "d" ];
+      const df = new dfd.Series(data, { index });
+      /* @ts-ignore */
+      assert.throws(function () { df.iat("A"); }, Error, "ParamError: row index must be an integer. Use .at to get a row by label.");
+    });
+  });
+
+  describe("at", function () {
+    it("at works on Series", function () {
+      const data = [ 1, 2, 3, 4 ];
+      const index = [ "a", "b", "c", "d" ];
+      const df = new dfd.Series(data, { index });
+      assert.equal(df.at("a"), 1);
+      assert.equal(df.at("b"), 2);
+      assert.equal(df.at("c"), 3);
+    });
+    it("at can return undefined", function () {
+      const data = [ 1, undefined, null, NaN ];
+      const index = [ "a", "b", "c", "d" ];
+      const df = new dfd.Series(data, { index });
+      assert.equal(df.at("b"), undefined);
+      assert.equal(df.at("c"), null);
+      /* @ts-ignore */
+      assert.equal(isNaN(df.at("d")), true);
+    });
+    it("throws error on string indices", function () {
+      const data = [ 1, 2, 3, 4 ];
+      const index = [ "a", "b", "c", "d" ];
+      const df = new dfd.Series(data, { index });
+      /* @ts-ignore */
+      assert.throws(function () { df.at(0); }, Error, "ParamError: row index must be a string. Use .iat to get a row by index.");
+    });
+
+  });
 });

src/danfojs-node/test/core/series.test.ts

@@ -1591,4 +1591,58 @@ describe("Series Functions", () => {
             assert.deepEqual(sf.and(data2).index, expected);
         });
     });
+
+    describe("iat", function () {
+        it("iat works on Series", function () {
+            const data = [1, 2, 3, 4];
+            const index = ["a", "b", "c", "d"];
+            const df = new Series(data, { index });
+            assert.equal(df.iat(0), 1);
+            assert.equal(df.iat(1), 2);
+            assert.equal(df.iat(2), 3);
+        });
+        it("iat can return undefined", function () {
+            const data = [1, undefined, null, NaN];
+            const df = new Series(data);
+            assert.equal(df.iat(1), undefined);
+            assert.equal(df.iat(2), null);
+            /* @ts-ignore */
+            assert.equal(isNaN(df.iat(3)), true);
+        });
+        it("throws error on string indices", function () {
+            const data = [1, 2, 3, 4];
+            const index = ["a", "b", "c", "d"];
+            const df = new Series(data, { index });
+            /* @ts-ignore */
+            assert.throws(function () { df.iat("A"); }, Error, "ParamError: row index must be an integer. Use .at to get a row by label.");
+        });
+    })
+
+    describe("at", function () {
+        it("at works on Series", function () {
+            const data = [1, 2, 3, 4];
+            const index = ["a", "b", "c", "d"];
+            const df = new Series(data, { index });
+            assert.equal(df.at("a"), 1);
+            assert.equal(df.at("b"), 2);
+            assert.equal(df.at("c"), 3);
+        });
+        it("at can return undefined", function () {
+            const data = [1, undefined, null, NaN];
+            const index = ["a", "b", "c", "d"];
+            const df = new Series(data, { index });
+            assert.equal(df.at("b"), undefined);
+            assert.equal(df.at("c"), null);
+            /* @ts-ignore */
+            assert.equal(isNaN(df.at("d")), true);
+        });
+        it("throws error on string indices", function () {
+            const data = [1, 2, 3, 4];
+            const index = ["a", "b", "c", "d"];
+            const df = new Series(data, { index });
+            /* @ts-ignore */
+            assert.throws(function () { df.at(0); }, Error, "ParamError: row index must be a string. Use .iat to get a row by index.");
+        });
+
+    });
 })