Services & Resources / Wolfram Forums / MathGroup Archive
-----

MathGroup Archive 2008

[Date Index] [Thread Index] [Author Index]

Search the Archive

Re: Identical elements

  • To: mathgroup at smc.vnet.net
  • Subject: [mg88427] Re: Identical elements
  • From: tommcd <TCMcDermott at gmail.com>
  • Date: Mon, 5 May 2008 06:12:49 -0400 (EDT)
  • References: <fvhe2h$3th$1@smc.vnet.net>

On May 3, 11:16 am, KFUPM <hussain.alqaht... at gmail.com> wrote:
> Dear All
>
> I have a list  and i need to test whether all the elements in the list
> are identical or no. What is the efficient way to do that? The output
> should be true if all elements are the same and False otherwise. One
> line command is preferred if possible.
>
> Your help is highly appreciated.
>
> Regards,
>
> HMQ

Short answer:
   Count[x, x[[1]]] == Length[x]  seems efficient,
   especially for the case of large lists with most elements equal.

Longer:
As I've only very recently started to use Mathematica for
'programming' I thought I'd try a few different ways :
>From below you can see that count is best, followed by the Do loop
version.

Side note:
Coding the Do loop version was very traumatic for this Fortran
programmer as I've just
learned that Return behaves much differently in a Do loop than in a
For or While loop.
And the behaviour which to me seems more consistent (i.e same as For
and While)
can only be got by using the Return[_,Module] form which is not
documented & I
only discovered by searching this newsgroup. Moreover the current
documentation
(6.02) for return is sparse and doesn't really explain any of this
clearly.

When I do need a loop I prefer Do as it's simple (and close to the
Fortran do loop
in style so easy for quick conversion) and has the advantage that the
looping variables are localized. I know procedural programming is not
encouraged in Mathematica but
sometimes the flow of control is messy & it's not possible to reduce a
block of code
to a small function let alone a one liner.
I'm now not sure how a given Return[] nested in various loops an other
control structures
 behaves (other than by testing it by trial and error), and since the
Return[_,Module] is undocumented I guess it's not safe to use. I know
there's Throw/Catch etc. and the real
problem is I expected Return to behave like in Fortran/C, but I think
this does warrant
one or two sentences in the documentation as quite a few programmers
must come to
Mathematica from Fortran &/ C++.

Regards,

Tom McDermott.


In[1]:= f1[x_] :=
 Module[{x1 = x[[1]], i, n = Length[x]},
  For[i = 2, i <= n, i++, If[x[[i]] != x1, Return[False]]]; True]

In[2]:= f2[x_] :=
 Module[{x1 = x[[1]], n = Length[x]},
  Do[If[x[[i]] != x1, Return[False, Module]];, {i, 2, n}]; True]

In[3]:= f3[x_] := And @@ (# == x[[1]] & /@ x)

In[4]:= f4[x_] := Module[{x1 = x[[1]]}, And @@ (# == x1 & /@ x)]

In[5]:= f5[
  x_] := (Scan[If[# != x[[1]], Return[False]] &, x] === Null)

In[6]:= f6[x_] :=
 Module[{x1 = x[[1]]}, (Scan[If[# != x1, Return[False]] &, x] ===
    Null)]

In[7]:= f7[x_] := LengthWhile[x, # == x[[1]] &] == Length[x]

In[8]:= f8[x_] := Count[x, x[[1]]] == Length[x]

In[9]:=
t = ConstantArray[0, {9, 7}];
Do[
 For[n = 1; i = 1, n < 10^7, n *= 10; i++,
  x = ConstantArray[1, {n}];
  (*x=RandomInteger[{1,n},n];*)
  x[[RandomInteger[{1, n}]]] = 0;
  t[[1, i]] += n;
  j = 1;
  Do[
   j++;
   t[[j, i]] += Timing[f[x]][[1]];
   , {f, {f1, f2, f3, f4, f5, f6, f7, f8}}
   ]
  ]
 , {k, 10}
 ]; MatrixForm[t/10]


Out[10]//MatrixForm= \!\(\*
TagBox[
RowBox[{"(", "\[NoBreak]", GridBox[{
{"1", "10", "100", "1000", "10000", "100000", "1000000"},
{"6.083675230250663`*^-16", "5.078402975922103`*^-16",
       "7.919012667834124`*^-16", "0.001299800000000279`",
       "0.013097899999999621`", "0.11298270000000028`",
       "1.1733215999999995`"},
{"6.083675230250663`*^-16", "0.00010000000000050794`",
       "7.919012667834124`*^-16", "0.0005999999999994859`",
       "0.0074988999999999655`", "0.06299050000000009`",
       "0.6567000999999999`"},
{"6.083675230250663`*^-16", "7.409871327634932`*^-16",
       "0.0003999000000004959`", "0.00119989999999912`",
       "0.01059839999999971`", "0.10818369999999931`",
       "1.0992327999999991`"},
{"5.079270337660091`*^-16", "0.00010000000000074099`",
       "0.00010000000000089772`", "0.0007998000000010313`",
       "0.007098899999999141`", "0.07198899999999954`",
       "0.7474868000000006`"},
{"5.079270337660091`*^-16", "7.919012667834124`*^-16",
       "0.0001999000000005075`", "0.0007998000000009498`",
       "0.007598899999999501`", "0.06838960000000004`",
       "0.7099917000000004`"},
{"5.079270337660091`*^-16", "7.919012667834124`*^-16",
       "5.845991008987528`*^-16", "0.0006000000000008052`",
       "0.006199100000000433`", "0.05239210000000059`",
       "0.5442175999999997`"},
{"0.00010000000000050794`", "0.00010000000000047177`",
       "0.0001000000000005846`", "0.00149979999999977`",
       "0.01489779999999977`", "0.12608060000000074`",
       "1.2976026000000003`"},
{"5.078402975922103`*^-16", "7.919012667834124`*^-16",
       "5.845096542195228`*^-16", "4.1227871810933796`*^-16",
       "0.000699799999999542`", "0.00899880000000006`",
       "0.09288559999999928`"}
},
GridBoxAlignment->{
      "Columns" -> {{Left}}, "ColumnsIndexed" -> {},
       "Rows" -> {{Baseline}}, "RowsIndexed" -> {}},
GridBoxSpacings->{"Columns" -> {
Offset[0.27999999999999997`], {
Offset[0.7]},
Offset[0.27999999999999997`]}, "ColumnsIndexed" -> {}, "Rows" -> {
Offset[0.2], {
Offset[0.4]},
Offset[0.2]}, "RowsIndexed" -> {}}], "\[NoBreak]", ")"}],
Function[BoxForm`e$,
MatrixForm[BoxForm`e$]]]\)



Side note: (maybe some gure can comment on this gripe)...
Coding the Do loop version was very traumatic for this Fortran
programmer as I've just
learned that Return behaves much differently in a Do loop than in a
For or While loop.
And the behaviour which to me seems more consistent (i.e same as For
and While)
can only be got by using the Return[_,Module] form which is not
documented & I
only discovered by searching this newsgroup. Moreover the current
documentation
(6.02) for return is sparse and doesn't really explain any of this
clearly.

When I do need a loop I prefer Do as it's simple (and close to the
Fortran do loop
in style so easy for quick conversion) and has the advantage that the
looping variables are localized. I know procedural programming is not
encouraged in Mathematica but
sometimes the flow of control is messy & it's not possible to reduce a
block of code
to a small function let alone a one liner.
I'm now not sure how a given Return[] nested in various loops an other
control structures
 behaves (other than by testing it by trial and error), and since the
Return[_,Module] is undocumented I guess it's not safe to use. I know
there's Throw/Catch etc. and the real
problem is I expected Return to behave like in Fortran/C, but I think
this does warrant
one or two sentences in the documentation as quite a few programmers
must come to
Mathematica from Fortran &/ C++.


  • Prev by Date: Re: Re: Locator
  • Next by Date: Solving on mathematica
  • Previous by thread: Re: Identical elements
  • Next by thread: Re: Identical elements