Concat along axis 1 for DataFrame

src/es6/__tests__/core/reshape/concat.js

@@ -62,5 +62,18 @@ describe('concat', () => {
       expect(frame3.get('x').values.toArray()).toEqual([1, 2, 3, 2, 3, 4]);
       expect(frame3.get('x').index.toArray()).toEqual([0, 1, 2, 3, 4, 5]);
     });
+
+    it('Concatenates two DataFrames along axis = 1 without ignoring index', () => {
+      const frame1 = new DataFrame([{x: 1, y: 2}, {x: 2, y: 3}, {x: 3, y: 4}]);
+      const frame2 = new DataFrame([{x: 2, y: 3}, {x: 3, y: 4}, {x: 4, y: 5}]);
+
+      const frame3 = concat([frame1, frame2], {axis: 1});
+      expect(frame3.get('x').values.toArray()).toEqual([1, 2, 3]);
+      expect(frame3.get('y').values.toArray()).toEqual([2, 3, 4]);
+      expect(frame3.get('x.x').values.toArray()).toEqual([2, 3, 4]);
+      expect(frame3.get('x.x').name).toEqual('x.x');
+      expect(frame3.get('y.x').values.toArray()).toEqual([3, 4, 5]);
+      expect(frame3.get('y.x').name).toEqual('y.x');
+    });
   });
 });

src/es6/core/reshape/concat.js

@@ -19,6 +19,7 @@ type T_ITER_SERIES = Array<Series> | Immutable.List<Series>;
 
 type T_KWARGS = {
   ignore_index: boolean,
+  axis?: 0 | 1,
 }
 
 const _concatSeriesValues = (objs: T_ITER_SERIES) =>
@@ -64,34 +65,45 @@ const _concatDataFrame = (objs: Array<DataFrame> | Immutable.List<DataFrame>,
     return objs.get(0);
 
   let seriesOrderedMap = Immutable.OrderedMap({});
-  objs.forEach((df: DataFrame) => {
-    const lenSeriesInMap = seriesOrderedMap.keySeq().size === 0
-      ? 0
-      : seriesOrderedMap.first().length;
-    const nextLength = df.length + lenSeriesInMap;
-
-    seriesOrderedMap = Immutable.OrderedMap(
-      // Get entries already concated (already in seriesOrderedMap)
-      seriesOrderedMap.entrySeq().map(([column, series]) => {
-        if (df.columnExists(column))
+  if (kwargs.axis === 1) {
+    objs.forEach((df: DataFrame) => {
+      df.columns.forEach((column: string) => {
+        const columnExists = seriesOrderedMap.has(column);
+        seriesOrderedMap = seriesOrderedMap.set(
+          columnExists ? `${column}.x` : column, // $FlowIssue
+          columnExists ? df.get(column).rename(`${column}.x`) : df.get(column));
+      });
+    });
+  } else {
+    objs.forEach((df: DataFrame) => {
+      const lenSeriesInMap = seriesOrderedMap.keySeq().size === 0
+        ? 0
+        : seriesOrderedMap.first().length;
+      const nextLength = df.length + lenSeriesInMap;
+
+      seriesOrderedMap = Immutable.OrderedMap(
+        // Get entries already concated (already in seriesOrderedMap)
+        seriesOrderedMap.entrySeq().map(([column, series]) => {
+          if (df.columnExists(column))
+            return [
+              column, // $FlowIssue
+              _concatSeries([series, df.get(column)], kwargs)];
           return [
             column, // $FlowIssue
-            _concatSeries([series, df.get(column)], kwargs)];
-        return [
-          column, // $FlowIssue
-          _concatSeries([
-            series,
-            new Series(Immutable.Repeat(NaN, df.length).toList(), {index: df.index})],
-          kwargs)]; // Now merge with columns only in the "right" DataFrame
-      })).merge(Immutable.OrderedMap(
-      df.columns
-        .filter(column => !seriesOrderedMap.has(column))
-        .map(column => // $FlowIssue
-          ([column, lenSeriesInMap === 0 ? df.get(column) : _concatSeries([
-            new Series(Immutable.Repeat(NaN, nextLength)),
-            df.get(column)],
-          kwargs)]))));
-  });
+            _concatSeries([
+                series,
+                new Series(Immutable.Repeat(NaN, df.length).toList(), {index: df.index})],
+              kwargs)]; // Now merge with columns only in the "right" DataFrame
+        })).merge(Immutable.OrderedMap(
+        df.columns
+          .filter(column => !seriesOrderedMap.has(column))
+          .map(column => // $FlowIssue
+            ([column, lenSeriesInMap === 0 ? df.get(column) : _concatSeries([
+                new Series(Immutable.Repeat(NaN, nextLength)),
+                df.get(column)],
+              kwargs)]))));
+    });
+  }
 
   return new DataFrame(seriesOrderedMap);
 };
@@ -113,13 +125,13 @@ const _concatDataFrame = (objs: Array<DataFrame> | Immutable.List<DataFrame>,
  * // Returns Series([1, 2, 3, 4, 2, 3, 4, 5], {index: [0, 1, 2, 3, 4, 5, 6, 7]})
  * concat([series1, series2], {ignore_index: true});
  */
-const concat = (objs: T_OBJS, kwargs: T_KWARGS = {ignore_index: false}): T_CONCAT => {
+const concat = (objs: T_OBJS, kwargs: T_KWARGS = {ignore_index: false, axis: 0}): T_CONCAT => {
   if ((Array.isArray(objs) && objs[0] instanceof Series)
       || (objs instanceof Immutable.List && objs.get(0) instanceof Series))
     return _concatSeries(objs, {ignore_index: kwargs.ignore_index});
   else if ((Array.isArray(objs) && objs[0] instanceof DataFrame)
     || (objs instanceof Immutable.List && objs.get(0) instanceof DataFrame))
-    return _concatDataFrame(objs, {ignore_index: kwargs.ignore_index});
+    return _concatDataFrame(objs, {ignore_index: kwargs.ignore_index, axis: kwargs.axis});
   throw new Error('Not supported');
 };
 

src/es6/core/series.js

@@ -246,7 +246,7 @@ export default class Series extends NDFrame {
    * // Returns List [1, 2, 3]
    * ds.index;
    */
-  set index(index: Immutable.List|Array<number|string>) {
+  set index(index: Immutable.List | Array<number | string>) {
     this.set_axis(0, parseIndex(index, this.values));
   }