Discover MakerZone

MATLAB and Simulink resources for Arduino, LEGO, and Raspberry Pi

Learn more

Discover what MATLAB® can do for your career.

Opportunities for recent engineering grads.

Apply Today

Thread Subject:
Making a square matrix from two vector

Subject: Making a square matrix from two vector

From: Jerry

Date: 8 Feb, 2013 15:42:08

Message: 1 of 23

Hello,

"a" is a vector (size 1-by-11) and "b" is also a vector (size 11-by-1), in that the first number of these two vectors is the same so "a1"="b1".

I would like to create a square matrix (size of this matrix is 11-by-11), from these two vectors in that "a" is the first row of this matrix and "b" is the first column of this matrix. In fact, I am going to use this function [F = (a + b) + (a * b)] to fill out the rest of this matrix. So, the shape of matrix would be in this way:

a1=b1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11
b2 b2a2 b2a3 b2a4 b2a5.............................................
b3 b3a2 .......................................................................
b4 .................................................................................
b5 .................................................................................
b6 .................................................................................
b7 .................................................................................
b8 .................................................................................
b9 .................................................................................
b10 ..................................................................................
b11 .............................................................................b11a11

Thanks,
Jerry
  

Subject: Making a square matrix from two vector

From: Barry Shaw

Date: 8 Feb, 2013 16:55:10

Message: 2 of 23

"Jerry " <jerrycholo@gmail.com> wrote in message <kf36cg$6vt$1@newscl01ah.mathworks.com>...
> Hello,
>
> "a" is a vector (size 1-by-11) and "b" is also a vector (size 11-by-1), in that the first number of these two vectors is the same so "a1"="b1".
>
> I would like to create a square matrix (size of this matrix is 11-by-11), from these two vectors in that "a" is the first row of this matrix and "b" is the first column of this matrix. In fact, I am going to use this function [F = (a + b) + (a * b)] to fill out the rest of this matrix. So, the shape of matrix would be in this way:
>
> a1=b1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11
> b2 b2a2 b2a3 b2a4 b2a5.............................................
> b3 b3a2 .......................................................................
> b4 .................................................................................
> b5 .................................................................................
> b6 .................................................................................
> b7 .................................................................................
> b8 .................................................................................
> b9 .................................................................................
> b10 ..................................................................................
> b11 .............................................................................b11a11
>
> Thanks,
> Jerry
>

If you expand this to 11x11 I tihnk this is what you want to do?

>> a = [1 2 3 4];
b = [1 2 4 5];
c = ones(4,4);
c(1,:) = a; c(:,1) = b;
for i = 2 : 4
    for j = 2 : 4
        c(i,j) = c(i,1) + c (1,j) + c(i,1) * c (1,j);
    end
end
>> c

c =

     1 2 3 4
     2 8 11 14
     4 14 19 24
     5 17 23 29

Subject: Making a square matrix from two vector

From: dpb

Date: 8 Feb, 2013 18:40:27

Message: 3 of 23

On 2/8/2013 9:42 AM, Jerry wrote:
> "a" is a vector (size 1-by-11) and "b" is also a vector (size 11-by-1),
> in that the first number of these two vectors is the same so "a1"="b1".
> I would like to create a square matrix (size of this matrix is
> 11-by-11), from these two vectors in that "a" is the first row of this
> matrix and "b" is the first column of this matrix. In fact, I am going
> to use this function [F = (a + b) + (a * b)] to fill out the rest of
> this matrix. So, the shape of matrix would be in this way:
>
> a1=b1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11
> b2 b2a2 b2a3 b2a4 b2a5 ...
   b3 b3a2
> b4
...
>
> b9
> b10
> b11 ................................. b11a11
>

 >> a=1:4; b=[1:2:8]';
 >> [X,Y]=meshgrid(a,b);
 >> F = @(x,y) ((x+y) + (x.*y));
 >> c=zeros(length(a)); c(:,1)= b; c(1,:)=a;
 >> c(2:end,2:end)=arrayfun(F,X(2:end,2:end),Y(2:end,2:end));
 >> c
c =
      1 2 3 4
      3 11 15 19
      5 17 23 29
      7 23 31 39
 >>

I _think_ this is same order as you wanted; reverse X,Y here if the
inner portion of c is the transpose of what you're after...

--

Subject: Making a square matrix from two vector

From: james bejon

Date: 8 Feb, 2013 22:40:08

Message: 4 of 23

% Data
a = [1 2 3 4];
b = [1 2 4 5].';

% Engine
X = (b * a) + bsxfun(@plus, a, b);

% And if you insist…
X(1, :) = a;
X(:, 1) = b;

Subject: Making a square matrix from two vector

From: Bruno Luong

Date: 9 Feb, 2013 08:24:10

Message: 5 of 23

To have a cleaner code than BSXFUN, one can use
http://www.mathworks.com/matlabcentral/fileexchange/23821-bsxops

>> bsxops(1)
>> % Data
a = [1 2 3 4];
b = [1 2 4 5].';
>> x = b.*a + a + b

ans =

     3 5 7 9
     5 8 11 14
     9 14 19 24
    11 17 23 29

% Bruno

Subject: Making a square matrix from two vector

From: james bejon

Date: 9 Feb, 2013 10:04:08

Message: 6 of 23

Now that's neat. That should be shipped with Matlab!

Subject: Making a square matrix from two vector

From: Bruno Luong

Date: 9 Feb, 2013 10:14:09

Message: 7 of 23

"james bejon" wrote in message <kf56uo$l6j$1@newscl01ah.mathworks.com>...
> Now that's neat. That should be shipped with Matlab!

TMW is welcome to take the idea and incorporate to their engine.

The inconvenience of my implementation is it is slow due to overhead of function callings.

Bruno

Subject: Making a square matrix from two vector

From: james bejon

Date: 12 Feb, 2013 16:07:16

Message: 8 of 23

Bruno--I really like this bsxops stuff, and have started using it in some of my projects at work. In the process, I've realised something which (at least in my view) is rather odd (though is nothing to do with your functions), namely the result of:

(1:10).' + 1:10

% the right way: (1:10).' + (1:10)

Subject: Making a square matrix from two vector

From: Steven_Lord

Date: 12 Feb, 2013 16:50:15

Message: 9 of 23



"james bejon" <jamesbejon@yahoo.co.uk> wrote in message
news:kfdpbk$kdo$1@newscl01ah.mathworks.com...
> Bruno--I really like this bsxops stuff, and have started using it in some
> of my projects at work. In the process, I've realised something which (at
> least in my view) is rather odd (though is nothing to do with your
> functions), namely the result of:
>
> (1:10).' + 1:10
>
> % the right way: (1:10).' + (1:10)

This is intentional behavior.

http://www.mathworks.com/help/matlab/matlab_prog/operators.html#f0-38155

Parentheses are at level 1 in the precedence order. Transpose is at level 2.
Addition is at level 5. The colon operator is at level 6. Therefore this:

(1:10).' + 1:10

computes (1:10) first (level 1 and level 6 inside the parentheses), then
transposes the result (level 2), then adds 1 to that result (level 5), then
uses that vector as the first input to the colon operator (level 6.) That
just takes the first element as documented on the reference page for COLON.

http://www.mathworks.com/help/matlab/ref/colon.html

"If you specify nonscalar arrays, MATLAB interprets j:i:k as
j(1):i(1):k(1)."

This also explains why your "the right way" resolves the problem; both sets
of parentheses at level 1 are processed before the addition at level 5.


This is also why -8^(1/3) gives -2 instead of (1+sqrt(3)*1i) as people
expect and sometimes post about here; exponentiation [8^(1/3)] is at level 2
while unary minus [- (8^(1/3))] is at level 3. (-8)^(1/3) gives the complex
answer.

--
Steve Lord
slord@mathworks.com
To contact Technical Support use the Contact Us link on
http://www.mathworks.com

Subject: Making a square matrix from two vector

From: Bruno Luong

Date: 12 Feb, 2013 21:35:22

Message: 10 of 23

It's not possible to explain better than Steve.

Just one thing:
  
> "If you specify nonscalar arrays, MATLAB interprets j:i:k as
> j(1):i(1):k(1)."
>

This is still incomplete to explain the result of:

a = 1i:10-2i

Discussed previously in http://www.mathworks.com/matlabcentral/newsreader/view_thread/261665

Bruno

Subject: Making a square matrix from two vector

From: dpb

Date: 12 Feb, 2013 22:29:43

Message: 11 of 23

On 2/12/2013 3:35 PM, Bruno Luong wrote:
> It's not possible to explain better than Steve.
>
> Just one thing:
>
>> "If you specify nonscalar arrays, MATLAB interprets j:i:k as
>> j(1):i(1):k(1)."
>>
>
> This is still incomplete to explain the result of:
>
> a = 1i:10-2i
>
> Discussed previously in
> http://www.mathworks.com/matlabcentral/newsreader/view_thread/261665

Don't know what the thread concluded (if anything) but empirically it
appears special-cased to ignore the imaginary parts (replacing them w/
0). IOW, it appears the parser turns the expression '1i:10-2i' into '0:10'

Examples--

 >> 2i:10-2i
Warning: Colon operands must be real scalars.
ans =
      0 1 2 3 4 5 6 7 8 9 10
 >> 2i:4-2i
Warning: Colon operands must be real scalars.
ans =
      0 1 2 3 4
 >> 2i:4
Warning: Colon operands must be real scalars.
ans =
      0 1 2 3 4
 >>

Seems as reasonable a choice as any if it isn't going to just error
entirely (which would probably be my first reaction of "proper"
behavior). Guess one could always have done abs() on the complex values
but seems like too much of a performance hit on the normal case might
result...

Why would anyone write such, anyway, and expect anything meaningful?
I'd relegate it to the bin of bad syntax and abort if it were my choice.

--

Subject: Making a square matrix from two vector

From: Bruno Luong

Date: 12 Feb, 2013 23:14:06

Message: 12 of 23

dpb <none@non.net> wrote in message <kfefok$qn7$1@speranza.aioe.org>...
> On 2/12/2013 3:35 PM, Bruno Luong wrote:

>
> Why would anyone write such, anyway, and expect anything meaningful?

What is "meaningful"?

Does the result of the following is more meaningful to you?

> sort([1 -2i])

Not long ago people claims x^2 = -1 is a meaningless equation.
 
Bruno

Subject: Making a square matrix from two vector

From: dpb

Date: 13 Feb, 2013 00:13:28

Message: 13 of 23

On 2/12/2013 5:14 PM, Bruno Luong wrote:
> dpb <none@non.net> wrote in message <kfefok$qn7$1@speranza.aioe.org>...
>> On 2/12/2013 3:35 PM, Bruno Luong wrote:
>
>>
>> Why would anyone write such, anyway, and expect anything meaningful?
>
> What is "meaningful"?
>

What do you think

1i:10-2i

should do?

Now, I can see there could argued to be a syntax for complex series
sequence generation, but it would need a complex delta...the previous
doesn't have any apparent difference that corresponds at all to the
implied unit difference of real colon inputs.

And, while it indeed was once a novel concept for complex variables,
it's now been quite some time... :)

I was, however, speaking in terms of defined ML syntax, not hypothetical.

--

Subject: Making a square matrix from two vector

From: james bejon

Date: 13 Feb, 2013 06:51:09

Message: 14 of 23

"Steven_Lord" <slord@mathworks.com> wrote in message <kfdrs7$rn$1@newscl01ah.mathworks.com>...
>
>
> "james bejon" <jamesbejon@yahoo.co.uk> wrote in message
> news:kfdpbk$kdo$1@newscl01ah.mathworks.com...
> > Bruno--I really like this bsxops stuff, and have started using it in some
> > of my projects at work. In the process, I've realised something which (at
> > least in my view) is rather odd (though is nothing to do with your
> > functions), namely the result of:
> >
> > (1:10).' + 1:10
> >
> > % the right way: (1:10).' + (1:10)
>
> This is intentional behavior.
>
> http://www.mathworks.com/help/matlab/matlab_prog/operators.html#f0-38155
>
> Parentheses are at level 1 in the precedence order. Transpose is at level 2.
> Addition is at level 5. The colon operator is at level 6. Therefore this:
>
> (1:10).' + 1:10
>
> computes (1:10) first (level 1 and level 6 inside the parentheses), then
> transposes the result (level 2), then adds 1 to that result (level 5), then
> uses that vector as the first input to the colon operator (level 6.) That
> just takes the first element as documented on the reference page for COLON.
>
> http://www.mathworks.com/help/matlab/ref/colon.html
>
> "If you specify nonscalar arrays, MATLAB interprets j:i:k as
> j(1):i(1):k(1)."
>
> This also explains why your "the right way" resolves the problem; both sets
> of parentheses at level 1 are processed before the addition at level 5.
>
>
> This is also why -8^(1/3) gives -2 instead of (1+sqrt(3)*1i) as people
> expect and sometimes post about here; exponentiation [8^(1/3)] is at level 2
> while unary minus [- (8^(1/3))] is at level 3. (-8)^(1/3) gives the complex
> answer.
>
> --
> Steve Lord
> slord@mathworks.com
> To contact Technical Support use the Contact Us link on
> http://www.mathworks.com

Thanks for the explanation.

Subject: Making a square matrix from two vector

From: Bruno Luong

Date: 13 Feb, 2013 07:08:15

Message: 15 of 23

dpb <none@non.net> wrote in message <kfelra$b4d$1@speranza.aioe.org>...
> On 2/12/2013 5:14 PM, Bruno Luong wrote:
> > dpb <none@non.net> wrote in message <kfefok$qn7$1@speranza.aioe.org>...
> >> On 2/12/2013 3:35 PM, Bruno Luong wrote:
> >
> >>
> >> Why would anyone write such, anyway, and expect anything meaningful?
> >
> > What is "meaningful"?
> >
>
> What do you think
>
> 1i:10-2i
>
> should do?

I'm fine if it does exactly like currently. I link to a post where the behavior is described. I never complain about it, excepted that the behavior is currently not documented.

>
> Now, I can see there could argued to be a syntax for complex series
> sequence generation, but it would need a complex delta...the previous
> doesn't have any apparent difference that corresponds at all to the
> implied unit difference of real colon inputs.
>
> And, while it indeed was once a novel concept for complex variables,
> it's now been quite some time... :)
>
> I was, however, speaking in terms of defined ML syntax, not hypothetical.

If one wants to develop a function that accept any kind of numerical data, the behavior should be defined. So it is legitimate to speak how colon behave when feed in complex data. That's how a specification of a function is defined and developed. This is the basic concept of software development.

Now if user can't make head or tail with the behavior of such and such function, that's his problem.

Recently I use the fact that ([]:1) return an empty set, therefore allow me to save 1 test in my implementation. Is it meaningless?

Bruno

Subject: Making a square matrix from two vector

From: dpb

Date: 13 Feb, 2013 15:22:26

Message: 16 of 23

On 2/13/2013 1:08 AM, Bruno Luong wrote:
...

> If one wants to develop a function that accept any kind of numerical
> data, the behavior should be defined. So it is legitimate to speak how
> colon behave when feed in complex data. That's how a specification of a
> function is defined and developed. This is the basic concept of software
> development.

That's again my observation there is no definitive language reference
for Matlab--only a more or less complete narrative description.


> Now if user can't make head or tail with the behavior of such and such
> function, that's his problem.

Well, that's a problem when the behavior doesn't follow the description
but if there is no description it seems rather rude to blame that on the
user. :)

> Recently I use the fact that ([]:1) return an empty set, therefore allow
> me to save 1 test in my implementation. Is it meaningless?

Would all depend on context. Again, you bring in unrelated issues--the
question specifically was on what colon() would mean for complex input
when the two parts are separated by a different sign in the change
between their values--so that the implicit default unit step for reals
doesn't supply enough information to have a meaning.

One could, of course, define another set of defaults for the case, but
the parser already warns that the use of complex isn't legal so it's
hard to argue for anything but it being user error at the moment.

What any other case is for another particular piece of the language is
immaterial to this one.

--

Subject: Making a square matrix from two vector

From: Bruno Luong

Date: 14 Feb, 2013 07:11:09

Message: 17 of 23

dpb <none@non.net> wrote in message <kfgb3g$obo$1@speranza.aioe.org>...

>
> That's again my observation there is no definitive language reference
> for Matlab--only a more or less complete narrative description.

MATLAB language part is well defined (behavior of function declaration, input output, statements such as if swicth/case, while, the keyword end, ... The use of [], (), {}, Even COLON operator.

What can be considered narrative is the library functions that comes with. But they are not MATLAB language. Don't mix both.

>
>
> > Now if user can't make head or tail with the behavior of such and such
> > function, that's his problem.
>
> Well, that's a problem when the behavior doesn't follow the description
> but if there is no description it seems rather rude to blame that on the
> user. :)

I never blame anyone when the problem is not mine. :-)

>
> > Recently I use the fact that ([]:1) return an empty set, therefore allow
> > me to save 1 test in my implementation. Is it meaningless?
>
> Would all depend on context. Again, you bring in unrelated issues

Precision: They are not issues to me.

I tried to give you various examples for behavior and simply ask you whereas you consider as "meaningless". I never get a clear answer. You never backup the characteristic "meaningless" you state somewhere op top of this thread, beside given argument the result is not what you expect to be, and accuse that people using the odd usage of colon with complex numbers knows nothing about the language.

Here is one more (out context) example:

>> a = sort([10i 1])

a =

   1.0000 0 +10.0000i

>> a(1) < a(2)

ans =

     0

This might seem meaningless to you. Yet it's perfectly defined and documented behavior. So they mean something, at least to me.

Bruno

Subject: Making a square matrix from two vector

From: dpb

Date: 14 Feb, 2013 08:22:01

Message: 18 of 23

On 2/14/2013 1:11 AM, Bruno Luong wrote:
> dpb <none@non.net> wrote in message <kfgb3g$obo$1@speranza.aioe.org>...
>
>>
>> That's again my observation there is no definitive language reference
>> for Matlab--only a more or less complete narrative description.
>
> MATLAB language part is well defined (behavior of function declaration,
> input output, statements such as if swicth/case, while, the keyword end,
> ... The use of [], (), {}, Even COLON operator.
>
...

But even 'doc colon' is essentially narrative examples of what it does
w/ certain values--it doesn't say a thing about complex--nor does it
intimate there's a problem with it. So, it isn't completely defined or
at least user-documented; there well may be more formal definitions
inside TMW that aren't published.

If it were a complete description there wouldn't have been the question
of interpretation of the subject expression...

--

Subject: Making a square matrix from two vector

From: Bruno Luong

Date: 14 Feb, 2013 12:18:10

Message: 19 of 23

dpb <none@non.net> wrote in message <kfi6r9$lc6$1@speranza.aioe.org>...

>
> But even 'doc colon' is essentially narrative examples of what it does
> w/ certain values--it doesn't say a thing about complex--nor does it
> intimate there's a problem with it. So, it isn't completely defined or
> at least user-documented;

But I never say the contrary dpb.

IIRC, the behavior of a:b:c when a, b, c are (pure real) arrays are documented recently, (after the thread I provide the like earlier).

But the behavior for complex ins't (yet?) documenetd. Though the same behavior is reproductible in all MATLAB versions: it operates only on real part first element of the inputs. That's logical and meaningful IMO.

There are many things that are not documented. Just take a look at Yair's blog. Are things discussed there are meaningless to you? I thing Yair's blog is the most useful blog concerning MATLAB.

In many languages - even a strict one like C - the behavior of many function is not completely defined (such as malloc(0), or something as simple as the bit shift (a >> b)). The specific compiler will implement specific behavior, yet all of them are meaningful. Just like MATLAB colon.

Bruno

Subject: Making a square matrix from two vector

From: dpb

Date: 14 Feb, 2013 16:08:02

Message: 20 of 23

On 2/14/2013 6:18 AM, Bruno Luong wrote:
> dpb <none@non.net> wrote in message <kfi6r9$lc6$1@speranza.aioe.org>...
>
>>
>> But even 'doc colon' is essentially narrative examples of what it does
>> w/ certain values--it doesn't say a thing about complex--nor does it
>> intimate there's a problem with it. So, it isn't completely defined or
>> at least user-documented;
>
> But I never say the contrary dpb.

Well, that's progress, then....surely seemed to me you were arguing that
the original expression should have had some known meaning discernible a
priori.

> IIRC, the behavior of a:b:c when a, b, c are (pure real) arrays are
> documented recently, (after the thread I provide the like earlier).
>
> But the behavior for complex ins't (yet?) documenetd. Though the same
> behavior is reproductible in all MATLAB versions: it operates only on
> real part first element of the inputs. That's logical and meaningful IMO.

That's certainly one possible implementation--the point is again that
unless and until it is documented it isn't... :)

> There are many things that are not documented. Just take a look at
> Yair's blog. Are things discussed there are meaningless to you? I thing
> Yair's blog is the most useful blog concerning MATLAB.
>
> In many languages - even a strict one like C - the behavior of many
> function is not completely defined (such as malloc(0), or something as
> simple as the bit shift (a >> b)). The specific compiler will implement
> specific behavior, yet all of them are meaningful. Just like MATLAB colon.

But there's a very big difference -- take malloc() since you bring it
up. The C Standard states that malloc() w/ a size_t argument of zero is
implementation defined (w/ two possible conforming results).

While it isn't unique it's much more useful information to the developer
than if it weren't mentioned what happens--when one knows where "there
be dragons" regions are, then it is possible to know one needs to take
appropriate steps to avoid or slay same.

My complaint is (and has been for a long time) that that type of
completeness that a Standard language tries to incorporate is mostly
missing in Matlab documentation as there is no Standard document the
general user/public is allowed to see.

The documentation tends to be example-based rather than definitive
statement-based, even for base language elements. Thus the need for
poking around and finding out what undocumented things do do--which, of
course, since they are undocumented means if you rely upon them you may
find out your code broken at some point down the road.

--

Subject: Making a square matrix from two vector

From: dpb

Date: 14 Feb, 2013 20:41:11

Message: 21 of 23

On 2/14/2013 10:08 AM, dpb wrote:
> On 2/14/2013 6:18 AM, Bruno Luong wrote:
...

>>
>> In many languages - even a strict one like C - the behavior of many
>> function is not completely defined (such as malloc(0), or something as
>> simple as the bit shift (a >> b)). The specific compiler will implement
>> specific behavior, yet all of them are meaningful. Just like MATLAB
>> colon.
>
> But there's a very big difference -- take malloc() since you bring it
> up. The C Standard states that malloc() w/ a size_t argument of zero is
> implementation defined (w/ two possible conforming results).
>
> While it isn't unique it's much more useful information to the developer
> than if it weren't mentioned what happens--when one knows where "there
> be dragons" regions are, then it is possible to know one needs to take
> appropriate steps to avoid or slay same.
...

That is, to be specific, the fundamental difference in documentation
philosophy in Matlab vis a vis a Standardized language is that the
Standard does intend to cover all cases in an unambiguous manner such
that an implementer can do so.

If, in fact, you can find a boundary case or somesuch that is not
covered, there is an error in the Standard and there is a formal
procedure to get official interpretations and update/correct the
Standard for the omission/error/oversight. That's a marked philosophy
difference from the way Matlab is documented (at least externally--I'm
sure there's something more nearly equivalent internally, but that's of
essentially no help to the user community since we're not privy to it).

--

Subject: Making a square matrix from two vector

From: James

Date: 18 Mar, 2013 13:16:17

Message: 22 of 23

"Bruno Luong" <b.luong@fogale.findmycountry> wrote in message <kf513a$26g$1@newscl01ah.mathworks.com>...
> To have a cleaner code than BSXFUN, one can use
> http://www.mathworks.com/matlabcentral/fileexchange/23821-bsxops
>
> >> bsxops(1)
> >> % Data
> a = [1 2 3 4];
> b = [1 2 4 5].';
> >> x = b.*a + a + b
>
> ans =
>
> 3 5 7 9
> 5 8 11 14
> 9 14 19 24
> 11 17 23 29
>
> % Bruno

Bruno--As mentioned above, I'm loving this submission.

A quick question/comment: I can't get "less than" to work

% This is OK
(1:10).' >= (1:10)

% but this errors
(1:10).' < (1:10)

Is this something deliberate? (i.e., did you figure users can just use ~(x >= y) and thus save on overloading )

Subject: Making a square matrix from two vector

From: Bruno Luong

Date: 19 Mar, 2013 04:37:16

Message: 23 of 23

"James" wrote in message <ki7431$ojt$1@newscl01ah.mathworks.com>...

>
> % but this errors
> (1:10).' < (1:10)

Make it:
(1:10) > (1:10)'

I only overload ">=" and ">". Not sure why?

Bruno

Tags for this Thread

What are tags?

A tag is like a keyword or category label associated with each thread. Tags make it easier for you to find threads of interest.

Anyone can tag a thread. Tags are public and visible to everyone.

Contact us