How to use “np.in” to filter prohibited values?

 In the context of Python programming language, you can filter out the entries from a Numpy-based array which are presented in a list of the prohibited values by using the “np.in1d” by using the logical negotiation(-) to create a mask which can select only the values of which are not in the prohibited list. Here is how you can do so:-

No.i I’d(array, values) would help you in returning a Boolean array which indicates whether each element of the “array” is presented in the “values” list. By applying a logical NOT(-) to this particular result, you can create a mask for the values that are not presented in the “values”. By using this mask, you can index the original array to exclude the prohibited values. Here is the coding-based solution given:-

Import numpy as np

Data = np.array([10, 15, 20, 25, 30, 35, 40])

Prohibited_values = [15, 30, 40]

# Create a boolean mask for values not in prohibited_values

Mask = ~np.in1d(data, prohibited_values)

# Apply the mask to filter out the prohibited values

Filtered_data = data[mask]

Print(filtered_data)

Output

[10 20 25 35]

Explanation

Np.in1d( data prohibited values) would help in creating a Boolean array which would indicate whether each element of “data” is in the “prohibited values”

  Result: [False, True, False, False, True, False, True]

Logical negotiation

You can invert the boolean array to indicate elements that are not in the prohibited values.

  Result:[ True, False, True, True, False, True, False]

Data[mask] would use the mask for indexing of the “data” excluding elements where the mask is False.

Here is a detailed Java-based example given below of how you can filter out entries from an array based on a list of the prohibited values. This example would include an explanation for each part of the code:-

Import java.util.Arrays;

Import java.util.HashSet;

Import java.util.Set;

Public class FilterArray {

    Public static void main(String[] args) {

        // Original data array

        Int[] data = {10, 15, 20, 25, 30, 35, 40};

        // List of prohibited values

        Int[] prohibitedValues = {15, 30, 40};

        // Filtered array

        Int[] filteredData = filterData(data, prohibitedValues);

        // Display the filtered data

        System.out.println(“Filtered data: “ + Arrays.toString(filteredData));

    }

    /**

     * Filters out the prohibited values from the data array.

     *

     * @param data             The original array of data.

     * @param prohibitedValues The array of prohibited values.

     * @return The filtered array with prohibited values removed.

     */

    Public static int[] filterData(int[] data, int[] prohibitedValues) {

        // Convert the prohibited values array to a Set for fast lookups

        Set prohibitedSet = new HashSet<>();

        For (int value : prohibitedValues) {

            prohibitedSet.add(value);

        }

        // Create an array to store the filtered data

        Int[] tempFiltered = new int[data.length];

        Int count = 0;

        // Iterate through the data array and include only non-prohibited values

        For (int value : data) {

            If (!prohibitedSet.contains(value)) {

                tempFiltered[count++] = value;

            }

        }

        // Copy the filtered values into the final array of appropriate size

        Int[] finalFilteredData = new int[count];

        System.arraycopy(tempFiltered, 0, finalFilteredData, 0, count);

        Return finalFilteredData;

    }

}