Ergebnisse für

440 - 459 von 602

Tran Tran
Letzte Aktivitätam 2 Mär. 2022

Submit solution for cody but my code has a built-in function

Hi everyone

I am a new of this community and I very interested in this forum and Matlab.I am trying to submit a soultion but as tiltle my code has a built-in function so the test systerm dont reconisie it.It run completely ok on my computer.

This is problem

https://www.mathworks.com/matlabcentral/cody/problems/45196-determine-whether-a-given-point-is-inside-or-outside-a-polygon/solutions/new

This is my solution

function [boOut] = BoIfPointInPoly(PolyMatrix,p_test)
%Summary of this function goes here
%{
if we draw a line from test point to a central point of a side of The polygon
then we extend that line to the furthest point of the polygon ensure that
line go through all side of Polygon in 1 direction.I call that line is line_test
Next find number of intersert of line test and all sides w polyxpoly
function
num interset point is odd mean p_test inside
num interset point is even mean p_test outside
this solution go from the concept that if a line go in from a side it has go out
from other side.So if it go in but not go out that mean it start from
inside.
%}
%   Detailed explanation goes here
%line from p test throuh central of a side to furthest point of polygon
%find vector
V = ((PolyMatrix(1,:) + PolyMatrix(2,:)) /2) - p_test ;
%draw that vector to furtest point
pend = p_test + V * max(PolyMatrix(:));
%with multi of V and biggest element I assume that line will go all out the
%polygon which ensure out logic will right
line_test = [p_test ; pend];
disp('Our line test\n');
disp(line_test);
 
%find interst point
p_inter = polyxpoly(PolyMatrix(:,1),PolyMatrix(:,2),line_test(:,1),line_test(:,2));
%find number of interset (row)
[numIntere,trash] = size(p_inter);
disp('Number of interest point:');
disp(numIntere);
%determine in or out
if (rem(numIntere,2) == 0)
    boOut = 0;
else
    boOut = 1;
end
end

Can anyone has solution.

cody

Tips & Tricks

Stephen23
Letzte Aktivitätam 12 Apr. 2024

TUTORIAL: Comma-Separated Lists and How to Use Them

Introduction

Comma-separated lists are really very simple. You use them all the time. Here is one:

a,b,c,d

That is a comma-separated list containing four variables, the variables a, b, c, and d. Every time you write a list separated by commas then you are writing a comma-separated list. Most commonly you would write a comma-separated list as inputs when calling a function:

fun(a,b,c,d)

or as arguments to the concatenation operator or cell construction operator:

[a,b,c,d]
{a,b,c,d}

or as function outputs:

[a,b,c,d] = fun();

It is very important to understand that in general a comma-separated list is NOT one variable (but it could be). However, sometimes it is useful to create a comma-separated list from one variable (or define one variable from a comma-separated list), and MATLAB has several ways of doing this from various container array types:

1) from a field of a structure array using dot-indexing:

struct_array.field        % all elements
struct_array(idx).field   % selected elements

2) from a cell array using curly-braces:

cell_array{:}             % all elements
cell_array{idx}           % selected elements

3) from a string array using curly-braces:

string_array{:}           % all elements
string_array{idx}         % selected elements

Note that in all cases, the comma-separated list consists of the content of the container array, not subsets (or "slices") of the container array itself (use parentheses to "slice" any array). In other words, they will be equivalent to writing this comma-separated list of the container array content:

content1, content2, content3, .. , contentN

and will return as many content arrays as the original container array has elements (or that you select using indexing, in the requested order). A comma-separated list of one element is just one array, but in general there can be any number of separate arrays in the comma-separated list (zero, one, two, three, four, or more). Here is an example showing that a comma-separated list generated from the content of a cell array is the same as a comma-separated list written explicitly:

>> C = {1,0,Inf};
>> C{:}
ans =
     1
ans =
     0
ans =
   Inf
>> 1,0,Inf
ans =
     1
ans =
     0
ans =
   Inf

How to Use Comma-Separated Lists

Function Inputs: Remember that every time you call a function with multiple input arguments you are using a comma-separated list:

fun(a,b,c,d)

and this is exactly why they are useful: because you can specify the arguments for a function or operator without knowing anything about the arguments (even how many there are). Using the example cell array from above:

>> vertcat(C{:})
ans =
    1
    0
  Inf

which, as we should know by now, is exactly equivalent to writing the same comma-separated list directly into the function call:

>> vertcat(1,0,Inf)
ans =
    1
    0
  Inf

How can we use this? Commonly these are used to generate vectors of values from a structure or cell array, e.g. to concatenate the filenames which are in the output structure of dir:

S = dir(..);
F = {S.name}

which is simply equivalent to

F = {S(1).name, S(2).name, S(3).name, .. , S(end).name}

Or, consider a function with multiple optional input arguments:

opt = {'HeaderLines',2, 'Delimiter',',', 'CollectOutputs',true);
fid = fopen(..);
C = textscan(fid,'%f%f',opt{:});
fclose(fid);

Note how we can pass the optional arguments as a comma-separated list. Remember how a comma-separated list is equivalent to writing var1,var2,var3,..., then the above example is really just this:

C = textscan(fid,'%f%f', 'HeaderLines',2, 'Delimiter',',', 'CollectOutputs',true)

with the added advantage that we can specify all of the optional arguments elsewhere and handle them as one cell array (e.g. as a function input, or at the top of the file). Or we could select which options we want simply by using indexing on that cell array. Note that varargin and varargout can also be useful here.

Function Outputs: In much the same way that the input arguments can be specified, so can an arbitrary number of output arguments. This is commonly used for functions which return a variable number of output arguments, specifically ind2sub and gradient and ndgrid. For example we can easily get all outputs of ndgrid, for any number of inputs (in this example three inputs and three outputs, determined by the number of elements in the cell array):

C = {1:3,4:7,8:9};
[C{:}] = ndgrid(C{:});

which is thus equivalent to:

[C{1},C{2},C{3}] = ndgrid(C{1},C{2},C{3});

Further Topics:

MATLAB documentation:

https://www.mathworks.com/help/matlab/matlab_prog/comma-separated-lists.html

https://www.mathworks.com/help/matlab/matlab_prog/access-multiple-elements-of-a-nonscalar-struct-array.html

https://www.mathworks.com/company/newsletters/articles/matlab-tips-and-tricks-exploiting-the-comma-separated-list-vectorizing-cell-array-and-structure-references.html

Click on these links to jump to relevant comments below:

Dynamic Indexing (indexing into arrays with arbitrary numbers of dimensions)

Nested Structures (why you get an error trying to index into a comma-separated list)

Summary

Just remember that in general a comma-separated list is not one variable (although they can be), and that they are exactly what they say: a list (of arrays) separated with commas. You use them all the time without even realizing it, every time you write this:

fun(a,b,c,d)