OpenModelica/C2/Arrays-in-Modelica/Gujarati

}

Time	Narration
00:01	Arrays પરનાં સ્પોકન ટ્યુટોરીયલમાં સ્વાગત છે.
00:05	આ ટ્યુટોરીયલમાં, આપણે શીખવા જઈ રહ્યા છીએ: કેવી રીતે array વેરીએબલો ઘોષિત કરવા છે, કેવી રીતે arrays ની રચના કરવી છે, કેવી રીતે for અને while લૂપો વાપરવા છે અને કેવી રીતે OMShell નો ઉપયોગ કરવો છે.
00:20	આ ટ્યુટોરીયલને રેકોર્ડ કરવા માટે, હું વાપરી રહ્યો છું: OpenModelica 1.9.2
00:26	તમે આ ટ્યુટોરીયલનો અભ્યાસ કરવા માટે આપેલમાંથી કોઈપણ ઓપરેટીંગ સિસ્ટમનો ઉપયોગ કરી શકો છો.
00:32	આ ટ્યુટોરીયલને સમજવા તથા અભ્યાસ કરવા માટે: તમને કોઈપણ પ્રોગ્રામિંગ ભાષામાં arrays નું જ્ઞાન હોવું જરૂરી છે.
00:40	તમને Modelica માં class ને વ્યાખ્યાયિત કરતા આવડવું જોઈએ. પૂર્વજરૂરીયાત ટ્યુટોરીયલોને અમારી વેબસાઈટ પર ઉલ્લેખવામાં આવ્યા છે. કૃપા કરી તેનો સંદર્ભ લો.
00:50	Vector એ એકલ પરિમાણીય એરે છે.
00:53	તે એકલ ઇન્ડેક્સ ધરાવે છે.
00:55	વેક્ટર ડીકલેરેશન (ઘોષણા) માટે Syntax દર્શાવ્યા પ્રમાણે છે.
00:50	દર્શાવેલ ઉદાહરણ વેક્ટર વેરીએબલ a ને ઘોષિત કરે છે જેનું માપ 2 છે.
01:05	એલીમેંટો (ઘટકો) ને છગડીયા કૌંસમાં સમાવિષ્ટ કરીને એક vector ની રચના કરી શકાવાય છે.
01:11	આ ઉદાહરણ vector પેરામીટર a વ્યાખ્યાયિત કરે છે જેમાં 2 અને 3 તેના એલીમેંટો તરીકે છે.
01:19	vector નાં એલીમેંટો એક્સેસ કરવા માટે, indexing ને સમજવું અનિવાર્ય છે.
01:25	vector indexing માટે Syntax દર્શાવ્યા પ્રમાણે છે.
01:29	Vector indexing એ 1 થી શરુ થાય છે અને Indices એ integers હોવા જોઈએ.
01:35	ચાલો polynomialEvaluatorUsingVectors નામનું એક function વિકસિત કરીએ.
01:41	આ function એ polynomialEvaluator ફંક્શનનું વિસ્તરણ છે જેને પાછલા ટ્યુટોરીયલોમાં ચર્ચા કરાયું હતું.
01:49	આપણે polynomialEvaluator નાં a,b અને c પેરામીટરોને વેક્ટર a થી બદલીશું.
01:58	કૃપા કરી આપણા Code Files લીંક પર ઉપલબ્ધ તમામ ફાઈલોને ડાઉનલોડ કરો અને સંગ્રહો.
02:05	તમારી સુવિધા માટે, polynomialEvaluator ફંક્શનને પણ ઉપલબ્ધ કરાયું છે.
02:12	હવે ચાલો આ ફંક્શનને ડેમોનસ્ટ્રેટ કરવા માટે હું OMEdit પર જાઉં.
02:17	OMEdit હવે Welcome પરિપ્રેક્ષ્યમાં ખૂલેલું છે.
02:21	મેં તમામ જરૂરી ફાઈલો ખોલી છે.
02:25	નોંધ લો આપેલ ક્લાસો અથવા ફંક્શનો હવે ઓએમએડીટમાં ખુલેલા છે: functionTester, matrixAdder, polynomialEvaluator અને polynomialEvaluatorUsingVectors.
02:42	હવે, તેમને જોવા માટે ચાલો હું દરેક આઇકોન પર બમણું ક્લિક કરું.
02:49	સારી રીતે દેખાવા માટે ચાલો હું OMEdit વિન્ડોને ડાબી બાજુએ ખસેડું.
02:56	polynomialEvaluator ટેબ પર જાવ.
03:00	તેને Text View માં ખોલો.
03:03	આ function પર વધુ માહિતી માટે, પાછલા ટ્યુટોરીયલોનો સંદર્ભ લો.
03:09	ચાલો હું polynomialEvaluatorUsingVectors પર જાઉં. તેને Text View માં ખોલીએ.
03:16	Input અને output વેરીએબલો polynomialEvaluator ફંક્શનમાં આવેલ પ્રમાણે જ છે.
03:23	polynomialEvaluator નાં a,b અને c પેરામીટરો વેક્ટર a થી બદલાયા છે.
03:32	આ વેક્ટરનું માપ 3 છે.
03:36	આ વેક્ટરનાં એલીમેંટો દર્શાવ્યા પ્રમાણે છગડીયા કૌંસમાં સમાવિષ્ટ કરાયા છે.
03:42	એલીમેંટોને comma દ્વારા જુદા પાડવામાં આવ્યા છે.
03:46	assignment સ્ટેટમેંટમાં વેક્ટર a નાં એલીમેંટોને તેમના સુચકાંકો વાપરીને એક્સેસ કરાયા છે.
03:54	a[1] એ વેક્ટર a નું પહેલું એલીમેંટ છે.
03:59	એજ પ્રમાણે, વેક્ટર a નાં બીજા એલીમેંટ અને ત્રીજા એલીમેંટને પણ એક્સેસ કરાયા છે.
04:08	હવે, ચાલો હું functionTester ટેબ પર જાઉં.
04:13	તેને Text View માં ખોલીએ.
04:16	આ ક્લાસ એ પાછલા ટ્યુટોરીયલમાં ચર્ચા કરેલ functionTester ક્લાસ પ્રમાણે જ છે.
04:24	z એ રિયલ (વાસ્તવિક) વેરીએબલ છે.
04:27	polynomialEvaluatorUsingVectors ફંક્શનને 10 એકમનાં input આર્ગ્યુંમેંટ સાથે કોલ (આવ્હાન) કરાયું છે.
04:35	આ ફંક્શન દ્વારા પાછી મળેલ વેલ્યુને z સાથે સમીકરણ કરાયી છે.
04:40	હવે ચાલો હું આ ક્લાસને સિમ્યુલેટ કરું.
04:43	Simulate બટન પર ક્લિક કરો.
04:46	પોપ અપ વિન્ડો બંધ કરો.
04:49	variables બ્રાઉઝરમાં z પસંદ કરો.
04:53	નોંધ લો z ની વેલ્યુ f(x) એટ x = 10 નાં બરાબર છે.
05:00	polynomialEvaluator ફંક્શનનાં કિસ્સામાં જોયા પ્રમાણે જ આ આલેખ છે.
05:07	હવે ચાલો હું z ને ના-પસંદ કરું અને પરિણામ રદ્દ કરું.
05:13	Modeling perspective પર પાછા જાવ.
05:16	હવે ચાલો હું સ્લાઈડ પર પાછો ફરું.
05:19	for લૂપનો ઉપયોગ આપેલ નિશ્ચિત વખત સુધી સ્ટેટમેંટો આઈટરેટ (દોહરાવવું) કરવા માટે થાય છે.
05:24	તેનો ઉપયોગ algorithm અને equation વિભાગોમાં થઇ શકે છે.
05:29	for લૂપ માટે Syntax ઉદાહરણ સાથે દર્શાવ્યા પ્રમાણે છે.
05:34	for લૂપનો ઉપયોગ કેવી રીતે કરવો છે તે ડેમોનસ્ટ્રેટ કરવા માટે ચાલો હું OMEdit પર પાછો ફરું.
05:40	polynomialEvaluatorUsingVectors ટેબ પર ક્લિક કરો.
05:45	fx માટે assignment સ્ટેટમેંટમાં, આપણે વેક્ટર a નાં એલીમેંટો એક્સેસ કરી રહ્યા છીએ.
05:52	આને for લૂપ વાપરીને પણ કરી શકાવાય છે.
05:55	હવે, ચાલો for લૂપને algorithm વિભાગમાં સમાવિષ્ટ કરવાનું જોઈએ.
06:01	પહેલા, બમણી સ્લેશને શરુ અને અંતમાં દાખલ કરીને fx માટે એસાઈનમેંટ સ્ટેટમેંટ Comment કરો.
06:10	Ctrl+S દાબીને આ ફંક્શનને સંગ્રહો.
06:15	જે for લૂપને દાખલ કરવાનું છે તેને for-loop.txt નામની ટેક્સ્ટ ફાઈલમાં આપવામાં આવ્યું છે.
06:23	તે અમારી વેબસાઈટ પર ઉપલબ્ધ છે. મેં આ ફાઈલને gedit વાપરીને ખોલી છે.
06:29	વિન્ડોઝ વપરાશકર્તા આ ફાઈલને ખોલવા માટે notepad અથવા એવું જ કોઈ ટેક્સ્ટ એડીટર વાપરી શકે છે.
06:35	ચાલો હું gedit પર જાઉં.
06:38	Ctrl+C દાબીને તમામ સ્ટેટમેંટોને કોપી કરો.
06:44	OMEdit પર પાછા આવો.
06:46	Enter દબાવો. Ctrl + V દાબીને તમામ સ્ટેટમેંટોને પેસ્ટ કરો.
06:53	આ ફંક્શનને Ctrl + S દાબીને સંગ્રહો.
06:57	હવે, ચાલો હું આ લૂપનાં દરેક સ્ટેટમેંટને સમજાવું.
07:02	લૂપનાં શરુ થવા પહેલા આ સ્ટેટમેંટ fx ને શરૂઆતી વેલ્યુ શૂન્ય એસાઈન કરે છે.
07:09	અહીં, i એ લૂપ ગણતરી તરીકે આપવામાં આવે છે.
07:12	લૂપ ત્યાંસુધી રન થાય છે જ્યાંસુધી i ની વેલ્યુ 3 થતી નથી.
07:16	i નો ઉપયોગ થાય એ પહેલા i ને ઘોષિત કરવું જરૂરી નથી.
07:21	ચાલો હું સેજ નીચેની તરફે સ્ક્રોલ કરું.
07:24	આ સ્ટેટમેંટ પુનરાવર્તિત રીતે બહુપદી f(x) નાં પદો ઉમેરે છે.
07:30	બહુપદી f(x) ની ચર્ચા polynomialEvaluator ફંક્શનની ચર્ચા કરતી વેળાએ થઇ હતી.
07:37	આ સ્ટેટમેંટ for લૂપનો અંત દર્શાવે છે.
07:41	હવે, આ ફંક્શન પૂર્ણ છે.
07:44	આ ફંક્શનને ચકાસવા માટે ચાલો functionTester ક્લાસ વાપરીએ.
07:49	મેં આ class માટે આ ફંક્શનમાં કોઈપણ ફેરફાર કર્યા નથી.
07:54	ચાલો હું ટૂલબારમાં આવેલ Simulate બટન દબાવીને આ ક્લાસને સિમ્યુલેટ કરું.
07:49	variables browser માં z પસંદ કરો.
08:03	નોંધ લો ફંક્શનમાં ફેરફાર કર્યા બાદ z ની વેલ્યુ સમાન રહે છે.
08:10	ચાલો હું z ને ના-પસંદ કરું અને પરિણામ રદ્દ કરું.
08:14	Modeling perspective પર પાછા જાવ.
08:17	હવે ફરી એકવાર ચાલો હું સ્લાઈડ પર પાછો ફરું.
08:21	જ્યાંસુધી આપેલ શરતનું સમાધાન થતું નથી ત્યાંસુધી while લૂપ સ્ટેટમેંટો આઈટરેટ (પુનરાવર્તિત) કરે છે.
08:27	while લૂપને equation વિભાગમાં વાપરી શકાતું નથી.
08:31	while ની સરખામણીએ for લૂપનો ઉપયોગ મોડેલીકામાં વારંવાર થાય છે.
08:37	ચાલો હવે Arrays ની ચર્ચા કરીએ.
08:40	Arrays નો ઉપયોગ multi-dimensional ડેટાને રજુ કરવા માટે થાય છે.
08:44	તેની રચના vector નોટેશન (સંકેતલિપિ) વાપરીને કરી શકાવાય છે.
08:48	array ઘોષણા અને indexing માટે Syntax દર્શાવ્યા પ્રમાણે છે.
08:55	array ની રચના અને indexing વિશે વધુમાં સમજવા માટે.
09:00	ચાલો matrixAdder નામનો એક class લખીએ જે mySum આપવા માટે myMatrix અને adder matrices ઉમેરે છે. myMatrix અને adder matrices એ દર્શાવ્યા પ્રમાણે છે.
09:14	હવે, ચાલો હું matrixAdder ક્લાસ ડેમોનસ્ટ્રેટ કરવા માટે OMEdit પર જાઉં.
09:19	તે OMEdit માં પહેલાથી જ ખૂલેલું છે.
09:23	matrixAdder ટેબ પર ક્લિક કરો.
09:26	તેને Text view માં ખોલો.
09:29	myMatrix એ એક Real પેરામીટર એરે છે.
09:33	ચોરસ કૌંસમાં આપેલ ક્રમાંક આ array નું માપ રજુ કરે છે.
09:39	પહેલા પરિમાણનું માપ 3 છે.
09:42	એજપ્રમાણે, બીજા પરિમાણનું માપ 2 છે.
09:46	myMatrix એરેની રચના દરેક બે એલીમેંટોનાં ત્રણ વેક્ટરો વાપરીને કરવામાં આવે છે.
09:53	{1,2} એ પહેલું વેક્ટર રજુ કરે છે.
09:57	{3,4} એ બીજુવાળું છે અને
10:00	{5,6}} એ ત્રીજા વેક્ટરને રજુ કરે છે.
10:04	આ દરેક વેક્ટરોનું માપ એ આ એરેનાં બીજા પરિમાણનાં માપ જેટલું હોય છે.
10:11	તેથી, માયમેટ્રીક્ષનાં બીજા પરિમાણનું માપ 2 છે.
10:16	વેક્ટરોની સંખ્યા એ પહેલા પરિમાણના માપ બરાબર છે. તેથી, પહેલા પરિમાણનું માપ એ 3 નાં બરાબર છે.
10:25	adder મેટ્રીક્ષને સમાન રીતે બનાવવામાં આવે છે.
10:29	આ બે એરે અને મેટ્રિસેસને ઉમેરવા માટે આપણે બે પરિમાણોમાંથી એલીમેંટોને એક્સેસ કરવાની જરૂર છે.
10:35	તેથી a nested for લૂપની જરૂર છે.
10:40	આ for લૂપ પહેલા પરિમાણ મારફતે રન થાય છે.
10:44	એજપ્રમાણે આ for લૂપ બીજા પરિમાણ મારફતે રન થાય છે.
10:49	ચાલો હું સેજ નીચે સ્ક્રોલ કરું.
10:52	myMatrix અને adder matrices નાં સંદર્ભિત એલીમેંટો યીલ્ડ mySum માં ઉમેરાયા છે.
11:00	આ સ્ટેટમેંટો દરેક for લૂપનું અંત રજુ કરે છે. ક્લાસ હવે પૂર્ણ થયો છે.
11:07	ચાલો હું આને Simulate બટન પર ક્લિક કરીને સિમ્યુલેટ કરું.
11:11	પોપ અપ વિન્ડો જો દ્રશ્યમાન થાય તો તેને બંધ કરો.
11:15	ચાલો હું variables કોલમને વિસ્તૃત કરું.
11:18	adder[1,1], myMatrix[1,1], અને mySum[1,1] પસંદ કરો.
11:25	નોંધ લો adder[1,1] પ્લસ myMatrix[1,1] એ mySum[1,1] આપે છે જેનો અર્થ છે કે પરિણામ ચોક્કસ છે.
11:35	ચાલો હું તેને ના-પસંદ કરું અને પરિણામ રદ્દ કરું.
11:40	ચાલો હું સ્લાઈડ પર પાછો ફરું.
11:43	એસાઈનમેંટ તરીકે: વેક્ટરમાં એલીમેંટોનાં ક્રમને ઉલટાવવા માટે vectorReversal નામનો ફંક્શન લખો.
11:51	એજપ્રમાણે મેટ્રીક્ષની દરેક હરોળમાં એલીમેંટોનાં ક્રમને ઉલટાવવા માટે matrixReversal ફંક્શન લખો.
12:00	આ બે ફંક્શનોને ચકાસવા માટે functionTester ક્લાસ લખો.
12:05	અહીં આ ટ્યુટોરીયલનો અંત થાય છે.
12:09	કૃપા કરી આપેલ લીંક પર ઉપલબ્ધ વિડીઓ નિહાળો: org /What\_is\_a\_Spoken\_Tutorial તે Spoken Tutorial પ્રોજેક્ટનો સારાંશ આપે છે.
12:15	અમે સ્પોકન ટ્યુટોરીયલોનો ઉપયોગ કરીને વર્કશોપો આયોજીત કરીએ છીએ. પ્રમાણપત્રો આપીએ છીએ. કૃપા કરી અમને સંપર્ક કરો.
12:21	જો તમને આ સ્પોકન ટ્યુટોરીયલથી સંબંધિત કોઈ પ્રશ્નો છે તો, કૃપા કરી આપેલ વેબસાઈટનો સંદર્ભ લો.
12:28	અમે લોકપ્રિય પુસ્તકોના ઉકેલાયેલા ઉદાહરણોના કોડિંગનું સંકલન કરીએ છીએ.
12:33	જેઓ આ કરે છે તેમને અમે માનદ અને પ્રમાણપત્રો આપીએ છીએ. કૃપા કરી આપેલ વેબસાઈટનો સંદર્ભ લો.
12:39	અમે વ્યવસાયિક સિમ્યુલેટર લેબોને ઓપનમોડેલીકામાં સ્થાનાંતરિત કરવામાં મદદ કરીએ છીએ. વધુ વિગત માટે કૃપા કરી આપેલ વેબસાઈટનો સંદર્ભ લો.
12:48	સ્પોકન ટ્યુટોરીયલ પ્રોજેક્ટને ફાળો NMEICT, MHRD, ભારત સરકાર દ્વારા આપવામાં આવ્યો છે.
12:55	અમે OpenModelica ની ડેવલપમેંટ (વિકાસ) ટીમનો તેમના સહકાર બદ્દલ આભાર માણીએ છીએ.
13:00	IIT Bombay તરફથી ભાષાંતર કરનાર હું, ભરત સોલંકી વિદાય લઉં છું. જોડવાબદ્દલ આભાર.

Contributors and Content Editors

Bharat636