public Row map()

in flink-ml-lib/src/main/java/org/apache/flink/ml/feature/interaction/Interaction.java [98:178]
72 lines of code
15 McCabe index (conditional complexity)

        public Row map(Row value) {
            int nnz = 1;
            boolean hasSparse = false;

            for (int i = 0; i < inputCols.length; ++i) {
                Object obj = value.getField(inputCols[i]);
                if (obj == null) {
                    return RowUtils.append(value, null);
                }

                if (obj instanceof DenseVector) {
                    featureSize[i] = ((Vector) obj).size();
                    if (featureIndices[i] == null || featureIndices[i].length != featureSize[i]) {
                        featureIndices[i] = new int[featureSize[i]];
                        for (int j = 0; j < featureSize[i]; ++j) {
                            featureIndices[i][j] = j;
                        }
                    }

                    featureValues[i] = ((DenseVector) obj).values;
                    nnz *= featureSize[i];
                } else if (obj instanceof SparseVector) {
                    featureSize[i] = ((Vector) obj).size();
                    featureIndices[i] = ((SparseVector) obj).indices;
                    featureValues[i] = ((SparseVector) obj).values;
                    nnz *= ((SparseVector) obj).values.length;
                    hasSparse = true;
                } else {
                    featureSize[i] = 1;
                    featureIndices[i] = new int[] {0};
                    featureValues[i] = new double[] {Double.parseDouble(obj.toString())};
                }
            }

            Vector ret;
            int featureIter = inputCols.length - 1;
            if (hasSparse) {
                int[] indices = new int[nnz];
                double[] values = new double[nnz];
                Arrays.fill(values, 1.0);
                int offset = 1;
                int size = 1;

                while (featureIter >= 0) {
                    int[] prevIndices = featureIndices[featureIter];
                    double[] prevValues = featureValues[featureIter];

                    for (int i = 0; i < nnz / offset; ++i) {
                        int idxOffset = i * offset;
                        int idx = i % prevValues.length;
                        for (int j = 0; j < offset; ++j) {
                            values[idxOffset + j] *= prevValues[idx];
                            indices[idxOffset + j] += prevIndices[idx] * size;
                        }
                    }

                    offset *= prevValues.length;
                    size *= featureSize[featureIter--];
                }
                ret = Vectors.sparse(size, indices, values);
            } else {
                double[] values = new double[nnz];
                Arrays.fill(values, 1.0);
                int idxOffset = 1;

                while (featureIter >= 0) {
                    double[] prevValues = featureValues[featureIter--];
                    for (int i = 0; i < nnz / idxOffset; ++i) {
                        int innerOffset = i * idxOffset;
                        int idx = i % prevValues.length;
                        for (int j = 0; j < idxOffset; ++j) {
                            values[innerOffset + j] *= prevValues[idx];
                        }
                    }
                    idxOffset *= prevValues.length;
                }
                ret = new DenseVector(values);
            }

            return RowUtils.append(value, ret);
        }