{"id":238,"date":"2016-08-10T10:53:49","date_gmt":"2016-08-10T18:53:49","guid":{"rendered":"http:\/\/wonghoi.humgar.com\/blog\/?p=238"},"modified":"2025-04-19T23:39:25","modified_gmt":"2025-04-20T07:39:25","slug":"matlab-techniques-self-identifying-by-type-methods","status":"publish","type":"post","link":"https:\/\/wonghoi.humgar.com\/blog\/2016\/08\/10\/matlab-techniques-self-identifying-by-type-methods\/","title":{"rendered":"MATLAB Techniques: Self-identifying (by type) methods"},"content":{"rendered":"

We all know MATLAB by default fill numbers with 0<\/code> if we haven’t specified them (such as expanding a matrix by\u00a0injecting values beyond\u00a0the original matrix size). Cells are default filled with {[]}<\/code> even if you meant\u00a0to have cellstr()<\/code>\u00a0 {''}<\/code> across the board. Sometimes it’s not what we wanted. 0<\/code> can be legitimate value, so we want NaN<\/code> to denote\u00a0undefined values. Same as cellstr()<\/code>, we don’t want to choke the default string processing programs\u00a0because one stupid {[]}<\/code> turns the entire cell array into\u00a0to a non-cellstr array.<\/p>\n

For compatibility reasons (and it’s also hard to do so), it’s not a good idea to simply modify the factory behavior. I have something similar to table() objects that requires similar expansion on\u00a0arbitrary data types, but MATLAB’s defaults proves to be clumsy.<\/p>\n

Instead of writing switch-case<\/code>\u00a0statements or a bunch of if<\/code>\u00a0statements that relies on type information like this:<\/p>\n

function x = makeUndefined(x)\n  switch class(x)\n    case {'double', 'single'}\n      x = NaN(size(x));\n    case 'cell'\n      if( iscellstr(x) )\n        x = repmat({''}, size(x));\n      end\n    % ...\n  end\n<\/pre>\n
I found a slick way to do it so I don’t have to keep track of it again if I need the same defaults in other places: take advantage of the fact that MATLAB selectively will load\u00a0the right method depending on the first input argument(s)*:<\/p>\n
Create\u00a0a commonly named method (e.g. makeUndefined()<\/code>) for the PODs and put it under the POD’s @folder (e.g. \/@double\/makeUndefined.m<\/code>, \/@cell\/makeUndefined.m<\/code>). The functions look something like this:<\/p>\n
function y = makeUndefined(x)\n% This function must be put under \/@double\n  y = NaN(size(x));<\/pre>\n
function x = makeUndefined(x)\n% This function must be put under \/@cell\n  if( iscellstr(x) )\n    x = repmat({''}, size(x));\n  end<\/pre>\n
Similarly, you can make your isundefined()<\/code> implementation for @double<\/code>, @cell,<\/code> etc, just like the factory-shipped\u00a0@categorical\/isundefined()<\/code> corresponding to the same rules you set for makeUndefined()<\/code>.<\/p>\n
Actually, the switch-case<\/code> approach is analogous to the common abuses of RTTI in C++: every time a new type is added, you have to open all the methods that depends on the type info and update them, instead of having the classes implement those methods (with proper object hierarchy and overloading).<\/p>\n
[Scott Meyers, “Effective C++”] Anytime you find yourself writing code of the form<\/em>\u00a0“if the object is of type T1, then do something, but if it’s of type T2, then do something else<\/em>,”\u00a0slap yourself<\/em><\/p><\/blockquote>\n
\n
This technique is especially valuable when you and TMW (or other users) have different ideas of what an English word (e.g. empty<\/em>, defined<\/em>, numeric<\/em>) means. Like do you consider boolean (logical) numeric<\/em>? TMW says no through isnumeric()<\/code>.<\/p>\n
To give you an example, I made a tool to nicely plot arbitrary features in my @table<\/code> over time (the equivalent of @timetable<\/code> before TMW introduced it). It only make sense if the associated dependent variable (y-axis) can be quantified, so\u00a0what I meant is broader<\/strong> than isnumeric()<\/code>: it’s isConvertibleToDouble()<\/code> since I casted my dependent variables with double()<\/code> in between.<\/p>\n
Boolean (logical) and categorical variables have quantifiable levels, so double()<\/code> can be applied to them, they should return TRUE<\/code> for isConvertibleToDouble()<\/code> despite isnumeric()<\/code> returns FALSE<\/code>. They have the same behavior for basic types like double(), single(), char(), cellstr(), struct()<\/code>, etc.<\/p>\n
In summary,<\/p>\n
    \n
  1. You say what you really mean<\/span> (by introducing nomenclature), NOT what it typically<\/strong> does
    \n– this is like creating another indirection like half(x)<\/code> instead of directly writing x\/2<\/code> or x>>1<\/code>.
    \n– spend 90% of your time coming up with a very intuitive yet precise name. ‘Misspoke’ == Bug!<\/li>\n
  2. The new data types self-manage through implementing methods<\/span> used by your code.
    \n– assume nothing about input type other than the interfaces that are accessed through
    \n(the traditional approach knows exactly what inputs they’re going to see)
    \n– if you did #1 correctly, there’s no reason to foresee\/prepare-for new input types
    \n(just implement the methods for the input data types that you want it to run for now)
    \n–\u00a0no sweep (switch-otherwise<\/code>) case to mishandle** unexpected new input data types
    \n(because it won’t run on an input data type until all called methods are implemented)
    \n– introducing new input data types won’t break the core code for existing types.
    \n(new input data types can only break themselves if they implemented the methods wrong)<\/li>\n<\/ol>\n
    \n
    * This is tricky business. MATLAB doesn’t have function overloading (by signature), but will look into the type\/class of FIRST dominant input argument and load the appropriate classes. Usually it’s the first argument, but for non-POD classes, you can specify the dominance relationship (Inferior classes<\/a>). Actually little has been said about such relationship in PODs in the official documentation.<\/p>\n
    I called support and found that there’s no dominance relationship in PODs, so it’s pretty much the first argument. That means this trick does not work if you want to overload\u00a0bsxfun()<\/code> for say, nominal()<\/code> objects (which doesn’t have a bsxfun()<\/code> implementation) keeping the same input argument order because the first argument is a function handle\u00a0for both the factory and the user method. Bummer!<\/p>\n
    [EDIT 2025\/04\/16]: Found new official documentation about the design consideration of MATLAB’s OOP<\/a> explicitly saying it’s the first (leftmost) argument that decides which function that shares the same function name gets called:<\/p>\n
    \"\"<\/a><\/p>\n
    This is why the new ‘*_fun<\/code>‘ functions I write, I always use the object to operate on as the first argument whenever possible. Gets a little bit ugly when I want to support multiple inputs like cellfun()<\/code>, so I have to weight whether it’s worth the confusion for the overloading capability.<\/p>\n
    ** Unless you want to torture yourself by listing all recognized types and make sure the ‘switch-otherwise<\/code>‘ case fails.<\/p>\n
    <\/div>\n
    <\/path><\/svg><\/i> \"Loading\"<\/p>\n
    <\/div>\n","protected":false},"excerpt":{"rendered":"
    We all know MATLAB by default fill numbers with 0 if we haven’t specified them (such as expanding a matrix by\u00a0injecting values beyond\u00a0the original matrix size). Cells are default filled with {[]} even if you meant\u00a0to have cellstr()\u00a0 {”} across … Continue reading →<\/span><\/a><\/p>\n
    <\/div>\n
    <\/path><\/svg><\/i> \"Loading\"<\/p>\n
    <\/div>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"inline_featured_image":false,"footnotes":""},"categories":[25,10,6],"tags":[26],"class_list":["post-238","post","type-post","status-publish","format-standard","hentry","category-cpp","category-matlab","category-note-to-self","tag-rtti"],"_links":{"self":[{"href":"https:\/\/wonghoi.humgar.com\/blog\/wp-json\/wp\/v2\/posts\/238","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/wonghoi.humgar.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/wonghoi.humgar.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/wonghoi.humgar.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/wonghoi.humgar.com\/blog\/wp-json\/wp\/v2\/comments?post=238"}],"version-history":[{"count":20,"href":"https:\/\/wonghoi.humgar.com\/blog\/wp-json\/wp\/v2\/posts\/238\/revisions"}],"predecessor-version":[{"id":6393,"href":"https:\/\/wonghoi.humgar.com\/blog\/wp-json\/wp\/v2\/posts\/238\/revisions\/6393"}],"wp:attachment":[{"href":"https:\/\/wonghoi.humgar.com\/blog\/wp-json\/wp\/v2\/media?parent=238"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/wonghoi.humgar.com\/blog\/wp-json\/wp\/v2\/categories?post=238"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/wonghoi.humgar.com\/blog\/wp-json\/wp\/v2\/tags?post=238"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}