How to use calculateInsertionCostOnFirstRow method of org.evomaster.client.java.instrumentation.coverage.methodreplacement.regex.CostMatrix class

Best EvoMaster code snippet using org.evomaster.client.java.instrumentation.coverage.methodreplacement.regex.CostMatrix.calculateInsertionCostOnFirstRow

Source:CostMatrix.java

...69         * 1) deletions followed by replacement70         * 2) as above, and then followed by insertions71         */72        final double[][][] matrix = new double[ROWS][COLUMNS][3];73        calculateInsertionCostOnFirstRow(graph, matrix);74        for (int i = 1; i < ROWS; i++) {75            for (int col = 0; col < COLUMNS; col++) {76                /*77                 * unless a path is explicitly updated, it will have maximum distance by default78                 */79                matrix[i][col][DEL] = Double.MAX_VALUE;80                matrix[i][col][REP] = Double.MAX_VALUE;81                matrix[i][col][INS] = Double.MAX_VALUE;82                for (GraphTransition t : graph.getIncomingTransitions(i, col)) {83                    int otherCol = graph.getColumn(t.fromState);84                    int otherRow = t.fromRow;85                    if (t.type.equals(GraphTransition.TransitionType.INSERTION)) {86                        assert otherRow == i;87                        /*88                         * if we have an insertion, only the insertion path can be continued.89                         * that's the reason why on the left side we only update for [INS].90                         * An insertion can continue any type of path (and so all types are present on the right side).91                         */92                        matrix[i][col][INS] = Math.min(matrix[i][col][INS], getSubPathCost(matrix[otherRow][otherCol][DEL], t.cost));93                        matrix[i][col][INS] = Math.min(matrix[i][col][INS], getSubPathCost(matrix[otherRow][otherCol][REP], t.cost));94                        matrix[i][col][INS] = Math.min(matrix[i][col][INS], getSubPathCost(matrix[otherRow][otherCol][INS], t.cost));95                    } else if (t.type.equals(GraphTransition.TransitionType.REPLACEMENT)) {96                        /*97                         * if we have a replacement, then we cannot continue a delete path.98                         * So, no [DEL] on the left side.99                         * A replacement can continue a delete or replace path, but not an insertion one (and so [DEL] and100                         * [REP] on right side)101                         */102                        matrix[i][col][REP] = Math.min(matrix[i][col][REP], getSubPathCost(matrix[otherRow][otherCol][DEL], t.cost));103                        matrix[i][col][REP] = Math.min(matrix[i][col][REP], getSubPathCost(matrix[otherRow][otherCol][REP], t.cost));104                        /*105                         * from this state on, an insertion path can be followed, with same cost (ie right side) as replacement path106                         */107                        matrix[i][col][INS] = Math.min(matrix[i][col][INS], getSubPathCost(matrix[otherRow][otherCol][DEL], t.cost));108                        matrix[i][col][INS] = Math.min(matrix[i][col][INS], getSubPathCost(matrix[otherRow][otherCol][REP], t.cost));109                    } else if (t.type.equals(GraphTransition.TransitionType.DELETION)) {110                        /*111                         * deletion can only follow a deletion path (so only [DEL] or right side).112                         * but, from this state on, any new path can be followed (so all on left side)113                         */114                        matrix[i][col][DEL] = Math.min(matrix[i][col][DEL], getSubPathCost(matrix[otherRow][otherCol][DEL], t.cost));115                        matrix[i][col][REP] = Math.min(matrix[i][col][REP], getSubPathCost(matrix[otherRow][otherCol][DEL], t.cost));116                        matrix[i][col][INS] = Math.min(matrix[i][col][INS], getSubPathCost(matrix[otherRow][otherCol][DEL], t.cost));117                    } else if (t.type.equals(GraphTransition.TransitionType.PHANTOM)) {118                        assert t.cost == 0;119                        /*120                         * artificial transition to final/sink state, so just take same values as previous state121                         */122                        matrix[i][col][DEL] = Math.min(matrix[i][col][DEL], matrix[otherRow][otherCol][DEL]);123                        matrix[i][col][REP] = Math.min(matrix[i][col][REP], matrix[otherRow][otherCol][REP]);124                        matrix[i][col][INS] = Math.min(matrix[i][col][INS], matrix[otherRow][otherCol][INS]);125                    }126                }127            }128            /*129             * TODO: The algorithm of Myers's paper, at page 12, makes a distinction between D and E transitions.130             * Insertions of type E are done last. Not fully clear if it has an effect here: ie, recall that131             * here we do minimization (calculate distance) and not maximization (similarity)132             */133        }134        /*135         * get the minimum among the 3 different paths in the sink state136         */137        double min = Double.MAX_VALUE;138        for (double value : matrix[ROWS - 1][COLUMNS - 1]) {139            if (value < min) {140                min = value;141            }142        }143        return min;144    }145    /**146     * We cannot just do previousStateCost + transitionCost, as there might be computational overflows147     *148     * @param previousStateCost149     * @param transitionCost150     * @return151     * @throws IllegalArgumentException152     */153    private static double getSubPathCost(double previousStateCost, double transitionCost) throws IllegalArgumentException {154        if (previousStateCost < 0) {155            throw new IllegalArgumentException("previousStateCost cannot be negative: " + previousStateCost);156        }157        if (transitionCost < 0) {158            throw new IllegalArgumentException("transitionCost cannot be negative: " + transitionCost);159        }160        if (previousStateCost == Double.MAX_VALUE || transitionCost == Double.MAX_VALUE) {161            return Double.MAX_VALUE;162        }163        double sum = previousStateCost + transitionCost;164        if (sum < previousStateCost || sum < transitionCost) {165            /*166             * likely overflow167             */168            return Double.MAX_VALUE;169        }170        return sum;171    }172    /**173     * First row is special, ie very different from the others174     *175     * @param graph176     * @param matrix177     */178    private static void calculateInsertionCostOnFirstRow(RegexGraph graph, final double[][][] matrix) {179        // First row is cost of matching empty sequence on regex180        final int FIRST_ROW = 0;181        /*182         * init first starting state with 0 costs183         */184        matrix[FIRST_ROW][0][0] = 0;185        matrix[FIRST_ROW][0][1] = 0;186        matrix[FIRST_ROW][0][2] = 0;187        for (int col = 1; col < graph.getNumberOfColumns(); col++) {188            double min = Double.MAX_VALUE;189            for (GraphTransition t : graph.getIncomingTransitions(FIRST_ROW, col)) {190                /*191                 * on first row, there can be only insertions coming from the same row,192                 * apart from last node that can have a phantom transition to sink state...

calculateInsertionCostOnFirstRow

Using AI Code Generation

1public class CostMatrix {2    public static void main(String[] args) {3        int[][] matrix = new int[4][4];4        matrix[0][0] = 0;5        matrix[0][1] = 1;6        matrix[0][2] = 2;7        matrix[0][3] = 3;8        matrix[1][0] = 1;9        matrix[1][1] = 0;10        matrix[1][2] = 1;11        matrix[1][3] = 2;12        matrix[2][0] = 2;13        matrix[2][1] = 1;14        matrix[2][2] = 0;15        matrix[2][3] = 1;16        matrix[3][0] = 3;17        matrix[3][1] = 2;18        matrix[3][2] = 1;19        matrix[3][3] = 0;20        int cost = CostMatrix.calculateInsertionCostOnFirstRow(matrix);21        System.out.println("Cost of insertion of a character on the first row of the matrix is " + cost);22        cost = CostMatrix.calculateDeletionCostOnFirstColumn(matrix);23        System.out.println("Cost of deletion of a character on the first column of the matrix is " + cost);24    }25    public static int calculateInsertionCostOnFirstRow(int[][] matrix) {26        int cost = 0;27        for (int i = 0; i < matrix[0].length; i++) {28            cost += matrix[0][i];29        }30        return cost;31    }32    public static int calculateDeletionCostOnFirstColumn(int[][] matrix) {33        int cost = 0;34        for (int i = 0; i < matrix.length; i++) {

calculateInsertionCostOnFirstRow

Using AI Code Generation

1public class ExampleController {2    public int calculateInsertionCostOnFirstRow(String a, String b) {3        return CostMatrix.calculateInsertionCostOnFirstRow(a, b);4    }5}6package org.evomaster.core.problem.rest.controller;7import com.foo.ExampleControlle

calculateInsertionCostOnFirstRow

Using AI Code Generation

1public void testInsertionCostOnFirstRow() {2    String[] patterns = new String[]{"a", "b"};3    String[] strings = new String[]{"a", "b"};4    CostMatrix matrix = new CostMatrix(patterns, strings);5    int cost = matrix.calculateInsertionCostOnFirstRow();6    assertEquals(2, cost);7}8public void testDeletionCostOnFirstColumn() {9    String[] patterns = new String[]{"a", "b"};10    String[] strings = new String[]{"a", "b"};11    CostMatrix matrix = new CostMatrix(patterns, strings);12    int cost = matrix.calculateDeletionCostOnFirstColumn();13    assertEquals(2, cost);14}15public void testSubstitutionCostOnFirstRow() {16    String[] patterns = new String[]{"a", "b"};17    String[] strings = new String[]{"a", "b"};18    CostMatrix matrix = new CostMatrix(patterns, strings);19    int cost = matrix.calculateSubstitutionCostOnFirstRow();20    assertEquals(0, cost);21}22public void testSubstitutionCostOnFirstColumn() {23    String[] patterns = new String[]{"a", "b"};24    String[] strings = new String[]{"a", "b"};25    CostMatrix matrix = new CostMatrix(patterns, strings);26    int cost = matrix.calculateSubstitutionCostOnFirstColumn();27    assertEquals(0, cost);28}

calculateInsertionCostOnFirstRow

Using AI Code Generation

1CostMatrix costMatrix = new CostMatrix(1);2String regex = "a{2}";3int cost = costMatrix.calculateInsertionCostOnFirstRow(regex);4assert cost == 2;5regex = "a{3}";6cost = costMatrix.calculateInsertionCostOnFirstRow(regex);7assert cost == 3;8regex = "a{4}";9cost = costMatrix.calculateInsertionCostOnFirstRow(regex);10assert cost == 4;11regex = "a{5}";12cost = costMatrix.calculateInsertionCostOnFirstRow(regex);13assert cost == 5;14regex = "a{6}";15cost = costMatrix.calculateInsertionCostOnFirstRow(regex);16assert cost == 6;17regex = "a{7}";18cost = costMatrix.calculateInsertionCostOnFirstRow(regex);19assert cost == 7;20regex = "a{8}";21cost = costMatrix.calculateInsertionCostOnFirstRow(regex);22assert cost == 8;23regex = "a{9}";

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.