OpenModelica/C2/Arrays-in-Modelica/Gujarati
From Script | Spoken-Tutorial
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 તરફથી ભાષાંતર કરનાર હું, ભરત સોલંકી વિદાય લઉં છું. જોડવાબદ્દલ આભાર. |