regex -> negate a word

x <- c("abcdef", "defabc", "qwerty")
x[-grep('abc',x)]

Dear all,

let's assume I have a vector of character strings:

x <- c("abcdef", "defabc", "qwerty")

What I would like to find is the following: all elements where the word
'abc' does not appear (i.e. 3 in this case of 'x').

Since I am not really experienced with regular expressions, I started
slowly and thought I find all word were 'abc' actually does appear:

grep(pattern="abc", x=x)

[1] 1 2

So far, so good. Now I read that ^ is the negation operator. But it can
also denote the beginning of a string as in:

grep(pattern="^abc", x=x)

[1] 1

Of course, we need to put it inside square brackets to negate the
expression [1]

grep(pattern="[^abc]", x=x)

[1] 1 2 3

But this is not what I want either.

I'd appreciate any help. I assume this is rather easy and
straightforward.

Thanks,
Roland


[1] http://www.zytrax.com/tech/web/regex.htm: The ^ (circumflex or
caret) inside square brackets negates the expression....

----------
This mail has been sent through the MPI for Demographic Research.  Should you receive a mail that is apparently from a MPI user without this text displayed, then the address has most likely been faked. If you are uncertain about the validity of this message, please check the mail header or ask your system administrator for assistance.

Dear all,

let's assume I have a vector of character strings:

x <- c("abcdef", "defabc", "qwerty")

What I would like to find is the following: all elements where the word
'abc' does not appear (i.e. 3 in this case of 'x').
  

Dear all,

let's assume I have a vector of character strings:

x <- c("abcdef", "defabc", "qwerty")

What I would like to find is the following: all elements where the word
'abc' does not appear (i.e. 3 in this case of 'x').

Since I am not really experienced with regular expressions, I started
slowly and thought I find all word were 'abc' actually does appear:

grep(pattern="abc", x=x)

[1] 1 2

So far, so good. Now I read that ^ is the negation operator. But it can
also denote the beginning of a string as in:

grep(pattern="^abc", x=x)

[1] 1

Of course, we need to put it inside square brackets to negate the
expression [1]

grep(pattern="[^abc]", x=x)

[1] 1 2 3

But this is not what I want either.

I'd appreciate any help. I assume this is rather easy and
straightforward.

Thanks,
Roland


[1] http://www.zytrax.com/tech/web/regex.htm: The ^ (circumflex or
caret) inside square brackets negates the expression....

----------
This mail has been sent through the MPI for Demographic Research.  Should you receive a mail that is apparently from a MPI user without this text displayed, then the address has most likely been faked. If you are uncertain about the validity of this message, please check the mail header or ask your system administrator for assistance.

Dear all,

let's assume I have a vector of character strings:

x <- c("abcdef", "defabc", "qwerty")

What I would like to find is the following: all elements where the word
'abc' does not appear (i.e. 3 in this case of 'x').

Since I am not really experienced with regular expressions, I started
slowly and thought I find all word were 'abc' actually does appear:

grep(pattern="abc", x=x)

[1] 1 2

So far, so good. Now I read that ^ is the negation operator. But it can
also denote the beginning of a string as in:

grep(pattern="^abc", x=x)

[1] 1

Of course, we need to put it inside square brackets to negate the
expression [1]

grep(pattern="[^abc]", x=x)

[1] 1 2 3

But this is not what I want either.

I'd appreciate any help. I assume this is rather easy and
straightforward.

Thanks,
Roland


[1] http://www.zytrax.com/tech/web/regex.htm: The ^ (circumflex or
caret) inside square brackets negates the expression....

----------
This mail has been sent through the MPI for Demographic Research.  Should you receive a mail that is apparently from a MPI user without this text displayed, then the address has most likely been faked. If you are uncertain about the validity of this message, please check the mail header or ask your system administrator for assistance.

Thank you very much to all of you for your fast and excellent help.
Since the "-grep(...)" solution seems to be favored by most of the answers,
I just wonder if there is really no regular expression which does the job?!?

Thanks again,
Roland



-----Original Message-----
From: Gabor Grothendieck [mailto:ggrothendieck at gmail.com]
Sent: Sun 1/18/2009 8:28 PM
To: Rau, Roland
Cc: r-help at r-project.org
Subject: Re: [R] regex -> negate a word

Try this:

# indexes
setdiff(seq_along(x), grep("abc", x))

# values
setdiff(x, grep("abc", x, value = TRUE))

Another possibility is:

z <- "abc"
x0 <- c(x, z) # to handle no match case
x0[- grep(z, x0)] # values




On Sun, Jan 18, 2009 at 1:35 PM, Rau, Roland <Rau at demogr.mpg.de> wrote:

Dear all,

let's assume I have a vector of character strings:

x <- c("abcdef", "defabc", "qwerty")

What I would like to find is the following: all elements where the word
'abc' does not appear (i.e. 3 in this case of 'x').

Since I am not really experienced with regular expressions, I started
slowly and thought I find all word were 'abc' actually does appear:

grep(pattern="abc", x=x)

[1] 1 2

So far, so good. Now I read that ^ is the negation operator. But it can
also denote the beginning of a string as in:

grep(pattern="^abc", x=x)

[1] 1

Of course, we need to put it inside square brackets to negate the
expression [1]

grep(pattern="[^abc]", x=x)

[1] 1 2 3

But this is not what I want either.

I'd appreciate any help. I assume this is rather easy and
straightforward.

Thanks,
Roland


[1] http://www.zytrax.com/tech/web/regex.htm: The ^ (circumflex or
caret) inside square brackets negates the expression....

----------
This mail has been sent through the MPI for Demographic Research.  Should
you receive a mail that is apparently from a MPI user without this text
displayed, then the address has most likely been faked. If you are uncertain
about the validity of this message, please check the mail header or ask your
system administrator for assistance.

Try this:


# values
setdiff(x, grep("abc", x, value = TRUE))

Another possibility is:

z <- "abc"
x0 <- c(x, z) # to handle no match case
x0[- grep(z, x0)] # values
  

Gabor Grothendieck wrote:

Try this:


# values
setdiff(x, grep("abc", x, value = TRUE))

Another possibility is:

z <- "abc"
x0 <- c(x, z) # to handle no match case
x0[- grep(z, x0)] # values

on quick testing, these two and the if-based version have comparable
runtime, with a minor win for the last one, and if the input is moderate
this makes no real difference.

however, the second solution above is likely to fail if the pattern is
more complex, e.g., contains a character class or a wildcard:

strings = c("xyz")
pattern = "a[a-z]"
strings[-grep(pattern, c(strings, pattern))]
# character(0)


vQ

In that case just add fixed = TRUE
  

Try this:

grep("^([^a]|a[^b]|ab[^c])*.{0,2}$", x, perl = TRUE)

  

On Sun, Jan 18, 2009 at 2:37 PM, Rau, Roland <Rau at demogr.mpg.de> wrote:
  

Thank you very much to all of you for your fast and excellent help.
Since the "-grep(...)" solution seems to be favored by most of the answers,
I just wonder if there is really no regular expression which does the job?!?
    

On Sun, Jan 18, 2009 at 2:37 PM, Rau, Roland <Rau at demogr.mpg.de> wrote:
  
    

Thank you very much to all of you for your fast and excellent help.
Since the "-grep(...)" solution seems to be favored by most of the answers,
I just wonder if there is really no regular expression which does the job?!?
    
      

in perl 5.10, you can try this:

@strings = ("abc", "xyz");
@filtered = grep $_ =~ /(abc)(*COMMIT)(*FAIL)|(*ACCEPT)/, @strings;

which works by making a string that matches the pattern fail, and any
other string succeed despite no match.
  

# r code
ungrep = function(pattern, x, ...)
    grep(paste(pattern, "(*COMMIT)(*FAIL)|(*ACCEPT)", sep=""), x,
perl=TRUE, ...)

strings = c("abc", "xyz")
pattern = "a[a-z]"
(filtered = strings[ungrep(pattern, strings)])
# "xyz"
  

Thanks! (I have to admit, though, that I expected something simple)

Thanks,
Roland



-----Original Message-----
From: Gabor Grothendieck [mailto:ggrothendieck at gmail.com]
Sent: Sun 1/18/2009 8:54 PM
To: Rau, Roland
Cc: r-help at r-project.org
Subject: Re: [R] regex -> negate a word

Try this:

grep("^([^a]|a[^b]|ab[^c])*.{0,2}$", x, perl = TRUE)


On Sun, Jan 18, 2009 at 2:37 PM, Rau, Roland <Rau at demogr.mpg.de> wrote:

Thank you very much to all of you for your fast and excellent help.
Since the "-grep(...)" solution seems to be favored by most of the
answers,
I just wonder if there is really no regular expression which does the
job?!?

Thanks again,
Roland



-----Original Message-----
From: Gabor Grothendieck [mailto:ggrothendieck at gmail.com]
Sent: Sun 1/18/2009 8:28 PM
To: Rau, Roland
Cc: r-help at r-project.org
Subject: Re: [R] regex -> negate a word

Try this:

# indexes
setdiff(seq_along(x), grep("abc", x))

# values
setdiff(x, grep("abc", x, value = TRUE))

Another possibility is:

z <- "abc"
x0 <- c(x, z) # to handle no match case
x0[- grep(z, x0)] # values




On Sun, Jan 18, 2009 at 1:35 PM, Rau, Roland <Rau at demogr.mpg.de> wrote:

Dear all,

let's assume I have a vector of character strings:

x <- c("abcdef", "defabc", "qwerty")

What I would like to find is the following: all elements where the word
'abc' does not appear (i.e. 3 in this case of 'x').

Since I am not really experienced with regular expressions, I started
slowly and thought I find all word were 'abc' actually does appear:

grep(pattern="abc", x=x)

[1] 1 2

So far, so good. Now I read that ^ is the negation operator. But it can
also denote the beginning of a string as in:

grep(pattern="^abc", x=x)

[1] 1

Of course, we need to put it inside square brackets to negate the
expression [1]

grep(pattern="[^abc]", x=x)

[1] 1 2 3

But this is not what I want either.

I'd appreciate any help. I assume this is rather easy and
straightforward.

Thanks,
Roland


[1] http://www.zytrax.com/tech/web/regex.htm: The ^ (circumflex or
caret) inside square brackets negates the expression....

----------
This mail has been sent through the MPI for Demographic Research.  Should
you receive a mail that is apparently from a MPI user without this text
displayed, then the address has most likely been faked. If you are
uncertain
about the validity of this message, please check the mail header or ask
your
system administrator for assistance.

Well, that's why it was only provided when you insisted.  This is
not what regexp's are good at.

On Sun, Jan 18, 2009 at 4:35 PM, Rau, Roland <Rau at demogr.mpg.de>  
wrote:

Thanks! (I have to admit, though, that I expected something simple)

On 19/01/2009, at 10:44 AM, Gabor Grothendieck wrote:

Well, that's why it was only provided when you insisted.  This is
not what regexp's are good at.

On Sun, Jan 18, 2009 at 4:35 PM, Rau, Roland <Rau at demogr.mpg.de> wrote:

Thanks! (I have to admit, though, that I expected something simple)

It may not be what regexp's are good at, but the grep command in unix/linux
does what is required *very* simply via the ``-v'' flag.  I conjecture that
it would not be difficult to add an argument with similar impact to the
grep() function in R.

       cheers,

               Rolf Turner

######################################################################
Attention:This e-mail message is privileged and confidential. If you are not
theintended recipient please delete the message and notify the sender.Any
views or opinions presented are solely those of the author.

This e-mail has been scanned and cleared by
MailMarshalwww.marshalsoftware.com
######################################################################

x <- c("abcdef", "defabc", "qwerty")
...[find] all elements where the word 'abc' does not appear (i.e. 3 in this case of 'x').

x[-grep("abc", x)]
which unfortunately fails if none of the strings in x matches the pattern, i.e., grep returns integer(0);

arguably, x[integer(0)] should rather return all elements of x

On Sun, Jan 18, 2009 at 2:22 PM, Wacek Kusnierczyk
<Waclaw.Marcin.Kusnierczyk at idi.ntnu.no> wrote:

x <- c("abcdef", "defabc", "qwerty")
...[find] all elements where the word 'abc' does not appear (i.e. 3 in this case of 'x').

x[-grep("abc", x)]
which unfortunately fails if none of the strings in x matches the pattern, i.e., grep returns integer(0);

Yes.

arguably, x[integer(0)] should rather return all elements of x

The meaning of x[V] (for an integer subscript vector V) is: ignore 0
entries, and then:

a) if !(all(V>0) | all(V<0) ) => ERROR
b) if all (V>0): length(x[V]) == length(V)
c) if all (V<0): length(x[V]) == length(x)-length(unique(V))

When length(V)==0, the preconditions are true for both (b) and (c), so
the R design has made the decision that length(x[V]) == 0 in this
case.  If you're going to have the "negative indices means exclusion"
trick, this seems like a reasonable convention.

Of course, that means that you can't in general use x[-V] (where
all(V>0)) to mean "all elements that are not in V".  However, there is
a workaround if you have an upper bound on length(x):

      x[ c(-2^30, -V) ]

This guarantees at least one negative number.

          -s

On 19/01/2009, at 10:44 AM, Gabor Grothendieck wrote:

Well, that's why it was only provided when you insisted.  This is
not what regexp's are good at.

On Sun, Jan 18, 2009 at 4:35 PM, Rau, Roland <Rau at demogr.mpg.de> wrote:

Thanks! (I have to admit, though, that I expected something simple)

It may not be what regexp's are good at, but the grep command in
unix/linux
does what is required *very* simply via the ``-v'' flag.  I conjecture
that
it would not be difficult to add an argument with similar impact to the
grep() function in R.

On Sun, Jan 18, 2009 at 2:22 PM, Wacek Kusnierczyk
<Waclaw.Marcin.Kusnierczyk at idi.ntnu.no> wrote:
  

x[-grep("abc", x)]
which unfortunately fails if none of the strings in x matches the pattern, i.e., grep returns integer(0);
    

Yes.

  

arguably, x[integer(0)] should rather return all elements of x
    

The meaning of x[V] (for an integer subscript vector V) is: 

ignore 0
entries, and then:
  

a) if !(all(V>0) | all(V<0) ) => ERROR
  

b) if all (V>0): length(x[V]) == length(V)
  

c) if all (V<0): length(x[V]) == length(x)-length(unique(V))
  

When length(V)==0, the preconditions are true for both (b) and (c), so
  

the R design has made the decision that length(x[V]) == 0 in this
case.  If you're going to have the "negative indices means exclusion"
trick, this seems like a reasonable convention.
  

On 19/01/2009, at 10:44 AM, Gabor Grothendieck wrote:

Well, that's why it was only provided when you insisted.  This is
not what regexp's are good at.

On Sun, Jan 18, 2009 at 4:35 PM, Rau, Roland <Rau at demogr.mpg.de> wrote:

Thanks! (I have to admit, though, that I expected something simple)

It may not be what regexp's are good at, but the grep command in unix/linux
does what is required *very* simply via the ``-v'' flag.  I conjecture that
it would not be difficult to add an argument with similar impact to the
grep() function in R.

On Mon, 19 Jan 2009, Rolf Turner wrote:

On 19/01/2009, at 10:44 AM, Gabor Grothendieck wrote:

Well, that's why it was only provided when you insisted.  This is
not what regexp's are good at.

On Sun, Jan 18, 2009 at 4:35 PM, Rau, Roland <Rau at demogr.mpg.de> wrote:

Thanks! (I have to admit, though, that I expected something simple)

It may not be what regexp's are good at, but the grep command in
unix/linux
does what is required *very* simply via the ``-v'' flag.  I
conjecture that
it would not be difficult to add an argument with similar impact to the
grep() function in R.

Indeed.  I have often wondered why grep() returned indices, when a
logical vector would seem more natural in R (and !grep(...) would have
been all that was needed).

Looking at the code I see it does in fact compute a logical vector,
just not return it.  So adding 'invert' (the long-form of -v is
--invert) is a job of a very few lines and I have done so for 2.9.0.

attached are patches to character.c, names.c, and grep.R; if you tell me