---
name: "numgrep"
section: "1"
platform: "linux"
package: "num-utils"
version: "0.5-15"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/numgrep"
---

# numgrep(1)

This program is the numeric equivilent of the grep utility.

## NAME

numgrep -  This program is the numeric equivilent of the grep utility.

## SYNOPSIS

**numgrep** \[-dhlV\] \<FILE\>

\| **numgrep** \[-dhlV\]   (Input on STDIN from pipeline.)

**numgrep** \[-dhlV\]     (Input on STDIN.  Use Ctrl-D to stop.)

## DESCRIPTION

**numgrep** searches for different occurrences of numbers through the use of numeric expressions.

## OPTIONS

```
    -l  Print the matching numbers out one per line
        instead of printing the entire line they are on.
    -h  Help: You're looking at it.
    -V  Increase verbosity.
    -d  Debug mode.  For developers
```

## EXPRESSIONS

**numgrep** uses a special numeric expression matching system.  Basically, it searches for ranges, factors and sequences of numbers.  Here is a list of the syntax characters and some sample expressions that will get you going:

```
    /<expression>/
         Put your expression or set of expressions between these
         two forward slashes.
    ..   Range expression.  A number must be used on the left
         and/or right of this expression to specify that numbers
         between, greater than or less than the numbers specified
         should be matched.
    ,    Expression separator.  The comma separates one complete
         expression from another in a set enclosed by //.
    m<n> Multiples of <n>.  This operator, followed by a number
          <n> will match any number <x> that is an integer
          multiple of <n>.  Meaning that <x> = <n> times <y>,
          where <y> is any integer.
    f<n> Factors of <n>.  This operator, followed by a number <n>
         will match any number <x> that is an integer factor of
         <n>.  Meaning that <x> = <n> divided by <y>, where <y>
         is any integer.
```

     **NOTE:** Checking for factors and multiples is very fast because it\
          is checked by doing a single modulus operation on two numbers.

**Examples:**

```
    /2..10/  Match any number between 2 and 10.
    /2..10,20..30/  Match any number between 2 and 10 or between 20 and 30.
    /56,34,512,45,67/  Match any of the numbers 56, 34, 512, 45 or 67.
    /m3/  Match any integer that is a multiple of 3.
    /f1024/  Match any integer that is a factor of 1024.
    $ numrange -N /1..1000/ | numgrep /f1024/
    1
    2
    4
    8
    16
    32
    64
    128
    256
    512
    $
```

## BUGS

**numgrep** can't handle certain situations properly.  Such as if it encounters a number with leading zeros, it will treat it as an octal number and thus might not match the way you would expect.

**numgrep** does not yet allow you to mix numbers and text in the matching expression.  So you can not do something like 'numgrep /port=0..1023/ firewall.log'. But this will be changed in the future.

## SEE ALSO

[**numaverage**(1)](/numaverage/1.md), [**numbound**(1)](/numbound/1.md), [**numinterval**(1)](/numinterval/1.md), [**numnormalize**(1)](/numnormalize/1.md), [**numprocess**(1)](/numprocess/1.md), [**numsum**(1)](/numsum/1.md), [**numrandom**(1)](/numrandom/1.md), [**numrange**(1)](/numrange/1.md), [**numround**(1)](/numround/1.md)

## COPYRIGHT

numgrep is part of the num-utils package, which is copyrighted by Suso Banderas and released under the GPL license.  Please read the COPYING and LICENSE files that came with the num-utils package

```
  Developers can read the GOALS file and contact me about providing
submitions or help for the project.
```

## BUGS

```
 numgrep will round decimal numbers with more than 15 digits of accuracy.  This is
mostly due to limit's in the way programming languages deal directly with numbers.
```

## MORE INFO

More info on numgrep can be found at:

- **http://suso.suso.org/xulu/Num-utils**