MaplePrimes Posts

MaplePrimes Posts are for sharing your experiences, techniques and opinions about Maple, MapleSim and related products, as well as general interests in math and computing.

Latest Post
  • Latest Posts Feed
  • The Embedded Components are containers that currently use industries for modeling complex systems to find viable solutions in real time and thus avoid huge wait times and overload our computer; by this paper should show you how to implement a dynamic worksheet through Embedded Components in Maple; it goes from finding solutions to ordinary differential equations partial; which interact with the researcher using different parameters.
    Using graphical programming will find immediate solutions to selected problems in science and engineering criteria of variability and boundary conditions evolving development with buttons on multiple actions.

     

    cimac_2014.pdf

    (in spanish)

    Solutions_of_Differential_Equations_with_Embedded_Components.mw

     

    Lenin Araujo Castillo

    Physics Pure

    Computer Science

     

    Someone asked on math.stackexchange.com about plotting x*y*z=1 and, while it's easy enough to handle it with implicitplot3d it raised the question of how to get nice constained axes in the case that the x- or y-range is much less than the z-range.

    Here's what WolframAlpha gives. (Mathematica handles it straight an an plot of the explict z=1/(x*y), which is interesting although I'm more interested here in axes scaling than in discontinuous 3D plots)

    Here is the result of a call to implicitplot3d with default scaling=unconstrained. The axes appear like in a cube, each of equal "length".

     

    Here is the same plot, with scaling=constrained. This is not pretty, because the x- and y-range are much smalled than the z-range.

     

    How can we control the axes scaling? Resizing the inlined plot window with the mouse just affects the window. The plot itself remains  rendered in a cube. Using right-click menus to rescale just makes all axes grow or shrink together.

    One unattractive approach it to force a small z-view on a plot of a much larger z-range, for a piecewise or procedure that is undefined outisde a specific range.

    plots:-implicitplot3d(proc(x,y,z)
                            if abs(z)>200 then undefined;
                            else x*y*z-1; end if;
                          end proc,
                          -1..1, -1..1, -200..200, view=[-1..1,-1..1,-400..400],
                          style=surfacecontour, grid=[30,30,30]);
    

    Another approach is to scale the x and y variables, scale their ranges, and then force scaled tickmark values. Here is a rough procedure to automate such a thing. The basic idea is for it to accept the same kinds of arguments are implicitplot3d does, with two extra options for scaling the axis x-relative-to-z, and axis y-relative-to-z.

    implplot3d:=proc( expr,
                      rng1::name=range(numeric),
                      rng2::name=range(numeric),
                      rng3::name=range(numeric),
                      {scalex::numeric:=1, scaley::numeric:=1} )
       local d1, d2, dz, n1, n2, r1, r2, rngs, scx, scy;
       uses plotfn=plots:-implicitplot3d;
       (n1,n2) := lhs(rng1), lhs(rng2);
       dz := rhs(rhs(rng3))-lhs(rhs(rng3));
       (scx,scy) := scalex*dz/(rhs(rhs(rng1))-lhs(rhs(rng1))),
                    scaley*dz/(rhs(rhs(rng2))-lhs(rhs(rng2)));
       (r1,r2) := map(`*`,rhs(rng1),scx), map(`*`,rhs(rng2),scy);
       (d1,d2) := rhs(r1)-lhs(r1), rhs(r1)-lhs(r1);
       plotfn( subs([n1=n1/scx, n2=n2/scy], expr),
               n1=r1, n2=r2, rng3, _rest[],
               ':-axis[1]'=[':-tickmarks'=[seq(i=evalf[3](i/scx),i=r1,d1/4)]],
               ':-axis[2]'=[':-tickmarks'=[seq(i=evalf[3](i/scy),i=r2,d2/4)]],
               ':-scaling'=':-constrained');
    end proc:
    

    The above could be better. It could also detect user-supplied custom x- or y-tickmarks and then scale those instead of forming new ones.

    Here is an example of using it,

    implplot3d( x*y*z=1, x=-1..1, y=-1..1, z=-200..200, grid=[30,30,30],
                style=surfacecontour, shading=xy, orientation=[-60,60,0],
                scalex=1.618, scaley=1.618 );
    

    Here is another example

    implplot3d( x*y*z=1, x=-5..13, y=-11..5, z=-200..200, grid=[30,30,30],
                style=surfacecontour, orientation=[-50,55,0],
                scaley=0.5 );
    

    Ideally I would like to see the GUI handle all this, with say (two or three) additional (scalar) axis scaling properties in a PLOT3D structure. Barring that, one might ask whether a post-processing routine could use plots:-transform (or friend) and also force the tickmarks. For that I believe that picking off the effective x-, y-, and z-ranges is needed. That's not too hard for the result of a single call to the plot3d command. Where it could get difficult is in handling the result of plots:-display when fed a mix of several spacecurves, 3D implicit plots, and surfaces.

    Have I overlooked something much easier?

    acer

    Presented at the National University of Trujillo - CUICITI 2014.

    IT Solutions for the Next Generation of Engineers

     

     

     

    Descarga aqui los Slides de la presentación/mw CUICITI-2014

    CUICITI_09102014.pdf

    Soluciones_Informáticas_para_la_siguiente_generación_de_Ingenieros.mw

    Lenin Araujo Castillo

    Physics Pure

    Computer Science

     

    Maplesoft regularly hosts live webinars on a variety of topics. Below you will find details on some upcoming webinars we think may be of interest to the MaplePrimes community.  For the complete list of upcoming webinars, visit our website.

    Maplesoft Solutions for Math Education

    This webinar will demonstrate how Maplesoft’s solutions for mathematics education help teachers bring complex problems to life, allow students to focus on concepts rather than the mechanics of solutions, and offer students the necessary practice to master the concepts being taught.

    Key takeaways include:

    • How to quickly and painlessly place incoming students in the correct math courses

    • How you can use hundreds of intuitive Clickable Math tools to demonstrate and explore up to advanced-level problems and algorithms in the classroom

    • How to automate your testing and assessment needs, specifically for math courses

    • How to bring your STEM courses to life in an online environment

    To join us for the live presentation, please click here to register.

    Introduction to Maple T.A. Placement Test Suite 10

    This webinar will provide an overview and demonstration of the latest release of the Maple T.A. MAA Placement Test Suite. A result of the ongoing partnership between the Mathematical Association of America (MAA) and Maplesoft, this product gives you the ability to provide the renowned MAA placement tests in an online testing environment. Learn how the Maple T.A. MAA Placement Test Suite can greatly simplify your placement process and explore the latest additions, including a streamlined interface and new tests to determine your students’ readiness for Precalculus and Algebra courses.

    To join us for the live presentation, please click here to register.

    There is also a recording available from another live webinar we did earlier this month: Introduction to Maple T.A. 10.

    After lots of hard work, vast amounts of testing, and enormous anticipation, Maple T.A. 10 is now available! Maple T.A. 10 is by far our biggest release to date - and we’re not just saying that. When we compare the list of new features and improvements in Maple T.A. 10 with that of previous releases, it’s clear that Maple T.A. 10 has the largest feature set and improvements to date.

    This application calculates the number of photons reaching a camera sensor for a given exposure. A blackbody model of the sun is generated. The "Sunny 16" rule for exposure is demonstrated. Calculations are done using units.Photon_Exposure_Array.mw

    Photon ExposureNULLNULL

    Blackbody Model of the Sun

        h := Units:-Standard:-`*`(Units:-Standard:-`*`(0.6626069e-33, Units:-Standard:-`^`(Unit('m'), 2)), Units:-Standard:-`*`(Unit('kg'), Units:-Standard:-`/`(Unit('s')))): 

    Plank Constant       

      kb := Units:-Standard:-`*`(Units:-Standard:-`*`(0.1380650e-22, Units:-Standard:-`*`(Units:-Standard:-`^`(Unit('m'), 2), Units:-Standard:-`/`(Units:-Standard:-`^`(Unit('s'), 2)))), Units:-Standard:-`*`(Unit('kg'), Units:-Standard:-`/`(Unit('K')))): 

    Boltzman Constant  

    c := Units:-Standard:-`*`(0.2997925e9, Units:-Standard:-`*`(Unit('m'), Units:-Standard:-`/`(Unit('s')))):  ``

    Light Speed

    Rsun := Units:-Standard:-`*`(Units:-Standard:-`*`(6.955, Units:-Standard:-`^`(10, 8)), Unit('m')): ``

    Sun Radius  

    Re_orb := Units:-Standard:-`*`(Units:-Standard:-`*`(1.496, Units:-Standard:-`^`(10, 11)), Unit('m')): ``

    Earth Orbit

    Tsun := Units:-Standard:-`*`(5800, Unit('K')): ``

    Sun Color Temperature     

     tf_atm := .718: 

    Transmission Factor  

     

    Sun: Spectral Radiant Exitance to Earth: Spectral Irradiance                   

      "M(lambda):=(2*Pi*h*c^(2))/((lambda)^(5))*1/((e)^((h*c)/(lambda*kb*Tsun))-1)*(Rsun/(Re_orb))^(2)*tf_atm:" NULL

    evalf(M(Units:-Standard:-`*`(555, Unit('nm')))) = 1277414308.*Units:-Unit(('kg')/(('m')*('s')^3))"(->)"1.277414308*Units:-Unit(('W')/(('nm')*('m')^2))NULL

    Photopic Relative Response VP vs λ

     

    csvFile := FileTools[Filename]("/VPhotopic.csv")NULL = "VPhotopic.csv"NULL

    VPdata := ImportMatrix(csvFile) = Vector(4, {(1) = ` 471 x 2 `*Matrix, (2) = `Data Type: `*float[8], (3) = `Storage: `*rectangular, (4) = `Order: `*Fortran_order})NULLNULL

     

    `λP` := [seq(1 .. 4000)]:

    VP := ArrayInterpolation(VPdata, `λP`):             (ArrayInterpolation for x,y data VPdata returns y' for new x data lambdaP)

    NULLVParray := [`$`([`λP`[n], VP[n]], n = 1 .. 4000)]:                     

    Mearth := [`$`([n, Units:-Standard:-`*`(Units:-Standard:-`*`(M(Units:-Standard:-`*`(n, Unit('nm'))), Unit('nm')), Units:-Standard:-`*`(Units:-Standard:-`^`(Unit('s'), 3), Units:-Standard:-`/`(Unit('kg'))))], n = 1 .. 4000)]:````

    ``

    dualaxisplot(plot([Mearth], lambda = 300 .. 900, style = line, color = [blue], labels = ["λ (nm)", "M (W/nm m^2)"], title = "Spectral Radiant Exitance of the Sun", titlefont = ["ARIAL", 15], legend = [Exitance], size = [800, 300]), plot([VParray], style = line, color = [green], labels = ["λ (nm)", "Relative Response"], legend = [Units:-Standard:-`*`(Units:-Standard:-`*`(Photopic, Relative), Response)]))

     

    ``

     

     

     

    Illuminance in Radiometric and Photometric Units:

    E__r := sum(Units:-Standard:-`*`(M(Units:-Standard:-`*`(lambda, Unit('nm'))), Unit('nm')), lambda = 200 .. 4000) = 984.7275549*Units:-Unit(('kg')/('s')^3)"(->)"984.7275549*Units:-Unit(('W')/('m')^2)NULL

    NULL

    E__po := Units:-Standard:-`*`(Units:-Standard:-`*`(683.002, Units:-Standard:-`*`(Unit('lm'), Units:-Standard:-`/`(Unit('W')))), sum(Units:-Standard:-`*`(Units:-Standard:-`*`(VP[lambda], M(Units:-Standard:-`*`(lambda, Unit('nm')))), Unit('nm')), lambda = 200 .. 4000)) = HFloat(91873.47376063903)*Units:-Unit('lx')NULL

    Translation from Illuminance to Luminance for Reflected Light;

     

    Object Reflectance          R__o:      

    Object Luminance           L__po := proc (R__o) options operator, arrow; R__o*E__po/(Pi*Unit('sr')) end proc:                evalf(L__po(1)) = HFloat(29244.234968360346)*Units:-Unit(('cd')/('m')^2) 

     

    Illuminance of a Camera Sensor  Eps applied for time texp determines Luminous Exposure Hp;

    Ideal Illuminance is determined by the exposure time texp, effective f-number N and to a less extent the angle to the optical axis θ;

     

    • 

    H       Luminous Exposure

    • 

    Eps     Illuminance to the Camera

    • 

    N                                               Effective F-Number

    • 

    texp             Exposure Time

    • 

    θ        Angle to the Optical Axis    

     

    E__ps_ideal = Units:-Standard:-`*`(Units:-Standard:-`*`(Units:-Standard:-`*`(Pi, Units:-Standard:-`/`(4)), L__po), Units:-Standard:-`*`(Units:-Standard:-`^`(cos(theta), 4), Units:-Standard:-`/`(Units:-Standard:-`^`(N, 2)))):

    H__p_ideal = Units:-Standard:-`*`(E__ps_ideal, t__exp):

     

    The camera meter determines the exposure time texp to balance the object luminance, reflectance and effective f-number. It does this based on an internal constant k and the camera ISO s.

    • 

    s        ISO Gain (Based on saturation at 3 stops above the average scene luminance)

    • 

    k       Reflected Light Meter Calibration Constant      k__m := Units:-Standard:-`*`(Units:-Standard:-`*`(12.5, Unit('lx')), Unit('s')):  

                                                                                                      for Nikon, Canon and Sekonic

    • 

    c        Incident Light Meter Calibration Constant       c__m := Units:-Standard:-`*`(Units:-Standard:-`*`(250, Unit('lx')), Unit('s')):        

                                                                                                      for Sekonic with flat domeNULL

    N^2/t__exp = `#mrow(mi("\`E__po\`"),mo("⋅"),mi("s"))`/c__m                        (Incident Light Meter)  NULL 

    Units:-Standard:-`*`(Units:-Standard:-`^`(N, 2), Units:-Standard:-`/`(t__exp)) = Units:-Standard:-`*`(`#mrow(mi("\`L__po\`"),mo("⋅"),mi("s"))`, Units:-Standard:-`/`(k__m)):                        (Reflected Light Meter)

    NULL

    Solve for H in terms of the Camera Meter Constant k and s

     

    Es = Units:-Standard:-`*`(Units:-Standard:-`*`(Units:-Standard:-`*`(Pi, Units:-Standard:-`/`(4)), Lo), Units:-Standard:-`*`(Units:-Standard:-`^`(cos(theta), 4), Units:-Standard:-`/`(Units:-Standard:-`^`(N, 2)))): NULL

    t = Units:-Standard:-`*`(Units:-Standard:-`*`(km, Units:-Standard:-`^`(N, 2)), Units:-Standard:-`/`(Units:-Standard:-`*`(Lo, s))):NULL

    NULL

    NULL

    H = Es*t

    H = Units:-Standard:-`*`(Units:-Standard:-`*`(Units:-Standard:-`*`(Units:-Standard:-`*`(Pi, Units:-Standard:-`/`(4)), Lo), Units:-Standard:-`*`(Units:-Standard:-`^`(cos(theta), 4), Units:-Standard:-`/`(Units:-Standard:-`^`(N, 2)))), Units:-Standard:-`*`(Units:-Standard:-`*`(km, Units:-Standard:-`^`(N, 2)), Units:-Standard:-`/`(Units:-Standard:-`*`(Lo, s))))"(=)"H = (1/4)*Pi*cos(theta)^4*km/sNULLNULL

     t = H/Es

    t = Units:-Standard:-`*`(Units:-Standard:-`*`(Units:-Standard:-`*`(Pi, Units:-Standard:-`/`(4)), Units:-Standard:-`*`(Units:-Standard:-`*`(Units:-Standard:-`^`(cos(theta), 4), km), Units:-Standard:-`/`(s))), Units:-Standard:-`/`(Units:-Standard:-`*`(Units:-Standard:-`*`(Units:-Standard:-`*`(Pi, Units:-Standard:-`/`(4)), Lo), Units:-Standard:-`*`(Units:-Standard:-`^`(cos(theta), 4), Units:-Standard:-`/`(Units:-Standard:-`^`(N, 2))))))"(=)"t = km*N^2/(Lo*s)NULLNULL

    H__p := proc (s, theta) options operator, arrow; (1/4)*Pi*k__m*cos(theta)^4/s end proc:                                              

      evalf(H__p(100, 0)) = 0.9817477044e-1*Units:-Unit(('cd')*('s')/('m')('radius')^2)"(->)"0.9817477044e-1*Units:-Unit(('lx')*('s'))NULL

     

    Note:  Meters are typically set for a scene reflectance 3 stops below 100% or 12.5%.

               

      E__ps := proc (N, R__o, theta) options operator, arrow; (1/4)*Pi*Unit('sr')*R__o*E__po*cos(theta)^4/(Pi*Unit('sr')*N^2) end proc:               

     evalf(E__ps(16, Units:-Standard:-`/`(Units:-Standard:-`^`(2, 3)), 0)) = HFloat(11.215023652421756)*Units:-Unit('lx')                                                                                                   

    t__exp_ideal := proc (N, s, R__o) options operator, arrow; H__p(s, theta)/E__ps(N, R__o, theta) end proc:                                     

      evalf(t__exp_ideal(16, 100, Units:-Standard:-`/`(Units:-Standard:-`^`(2, 3)))) = HFloat(0.008753862094289947)*Units:-Unit('s') NULL NULL

     

     

    Actual exposure time includes typical lens losses;

     m := Units:-Standard:-`/`(80):``

    Magnification  

      T := .9:``

    Lens Transmittance

     F := 1.03:``

    Lens Flare

    V := 1: ``

    Vignetting

     

                                                      ``

    Total Lens Efficiency

    q := Units:-Standard:-`*`(Units:-Standard:-`*`(Units:-Standard:-`*`(T, F), V), Units:-Standard:-`^`(Units:-Standard:-`+`(1, Units:-Standard:-`-`(m)), 2)):                                      evalf(q) = .9039698438NULL

     

    Replacing Eps with q*Eps we get the "Sunny 16" relation between exposure time and ISO;  NULL

    t__exp := proc (N, s, R__o) options operator, arrow; H__p(s, theta)/(q*E__ps(N, R__o, theta)) end proc:NULL               evalf(t__exp(16, 100, Units:-Standard:-`/`(Units:-Standard:-`^`(2, 3)))) = HFloat(0.009683798806264942)*Units:-Unit('s')NULL

    t__exp_alt := proc (N, s, R__o) options operator, arrow; k__m*N^2*Pi/(s*q*R__o*E__po) end proc:                  evalf(t__exp_alt(16, 100, Units:-Standard:-`/`(Units:-Standard:-`^`(2, 3)))) = HFloat(0.00968379880412244)*Units:-Unit('s') 

    • 

    The Number of Photons NP Reaching the Sensor Area A;

    • 

    Circle of confusion for 24x36mm "Full Frame" for 1 arcminute view at twice the diagonal:

                              A__cc := Units:-Standard:-`*`(Units:-Standard:-`*`(Pi, Units:-Standard:-`^`(Units:-Standard:-`*`(12.6, Unit('`μm`')), 2)), Units:-Standard:-`/`(4)):    

         

    • 

      Sensor Bandwidth                                          Photopic Response VP

    • 

      Exposure Time for Zone 5: Rscene=12.5% , Saturation in Zone 8 Rscene=100%

    • 

      Camera ISO differs from Saturation ISO. Typical Saturation ISO is 2300 when the camera is set to 3200. See DxoMark.

     

    NULL

    The average number of photons for exposure time based on Reflectance of the scene  relative to the metered value:    

    Zone 5;   R__meter := R__scene: 

    NP := proc (s, R__o, theta) options operator, arrow; (1/4)*t__exp(N, s, R__meter)*A__cc*q*R__scene*cos(theta)^4*(sum(VP[lambda]*M(lambda*Unit('nm'))*Unit('nm')*lambda*Unit('nm')/(h*c), lambda = 200 .. 4000))/N^2 end proc: 

                                                                                   evalf(NP(2300, 1, Units:-Standard:-`*`(0, Unit('deg')))) = HFloat(2191.5645712603696)  NULL

    Zone 8;       R__meter := Units:-Standard:-`*`(R__scene, Units:-Standard:-`/`(Units:-Standard:-`^`(2, 3))):   NULL

    NP__sat := proc (s, theta) options operator, arrow; (1/4)*t__exp(N, s, R__meter)*A__cc*q*R__scene*cos(theta)^4*(sum(VP[lambda]*M(lambda*Unit('nm'))*Unit('nm')*lambda*Unit('nm')/(h*c), lambda = 200 .. 4000))/N^2 end proc:  NULL

                                                                                  evalf(NP__sat(2300, Units:-Standard:-`*`(0, Unit('deg')))) = HFloat(17532.516570082957)NULL

    NULL

     

    Approximate Formula

     

    H__sat := proc (s__sat) options operator, arrow; H__p(s__sat, 0)*E__ps(N, 1, 0)/E__ps(N, 1/8, 0) end proc:      

                                                                                           evalf(H__sat(s__sat)) = HFloat(78.53981635)*Units:-Unit(('cd')*('s')/('m')('radius')^2)/s__satNULLNULL

    Average Visible Photon Energy

    P__e_ave := Units:-Standard:-`*`(Units:-Standard:-`/`(Units:-Standard:-`+`(850, -350)), sum(Units:-Standard:-`*`(Units:-Standard:-`*`(h, c), Units:-Standard:-`/`(Units:-Standard:-`*`(lambda, Unit('nm')))), lambda = 350 .. 850)):                    evalf(P__e_ave) = 0.3533174192e-18*Units:-Unit('J') 

    NPtyp := proc (s__sat) options operator, arrow; H__sat(s__sat)*A__cc/(683.002*(Unit('lm')/Unit('W'))*P__e_ave) end proc: 

                                   evalf(NPtyp(2300)) = HFloat(17644.363333654386)"(->)"HFloat(17644.363333654386)NULL

    NULL

     

    Download Photon_Exposure_Array.mw

    I would like to announce a new unofficial record computation of the MRB constant that was finished on Sun 21 Sep 2014 18:35:06.

    I really would like to see someone beat it with Maple!

    It took 1 month 27 days 2 hours 45 minutes 15 seconds. I computed 3,014,991 digits of the MRB constant, (confirming my previous 2,00,000 or more digit computation was actually accurate to 2,009,993 digits), with Mathematica 10.0. I Used my version of Richard Crandall's code:

     

    ____________________________________________________________________________

    (*Fastest (at MRB's end) as of 25 Jul 2014.*)

    DateString[]

    prec = 3000000;(*Number of required decimals.*)ClearSystemCache[];

    T0 = SessionTime[];

    expM[pre_] := 

      Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 12, 

        tsize = 2^7, chunksize, start = 1, ll, ctab, 

        pr = Floor[1.005 pre]}, chunksize = cores*tsize;

       n = Floor[1.32 pr];

       end = Ceiling[n/chunksize];

       Print["Iterations required: ", n];

       Print["end ", end];

       Print[end*chunksize]; d = ChebyshevT[n, 3];

       {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};

       iprec = Ceiling[pr/27];

       Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;

            x = N[E^(Log[ll]/(ll)), iprec];

            pc = iprec;

            While[pc < pr, pc = Min[3 pc, pr];

             x = SetPrecision[x, pc];

             y = x^ll - ll;

             x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(*N[Exp[Log[ll]/ll],

            pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, 

           Method -> "EvaluationsPerKernel" -> 4]];

        ctab = ParallelTable[Table[c = b - c;

           ll = start + l - 2;

           b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));

           c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 2];

        s += ctab.(xvals - 1);

        start += chunksize;

        Print["done iter ", k*chunksize, " ", SessionTime[] - T0];, {k, 0,

          end - 1}];

       N[-s/d, pr]];

    t2 = Timing[MRBtest2 = expM[prec];]; DateString[]

    Print[MRBtest2]

    MRBtest2 - MRBtest2M

    _________________________________________________________________________.

     

    I used a six core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz with 64 GB of RAM of which only 16 GB was used.

    t2 From the computation was {1.961004112059*10^6, Null}.

     

     

     

    This is an application of vector position to better understand the vector speed and acceleration is a well defined vector space. Fully developed with embedded components for proper use.

     

        Vector_Posición.mw                   (in spanish)

     

    L. Araujo C.

    Physics Pure

    Computer Science

    Obsolete

    See my Camera Profiler application instead.

     

    This application creates DNG matrices by optimizing Delta E from a raw photo of x-rites color checker. The color temperature for the photograph is also estimated.  Inputs are raw data from RawDigger and generic camera color response from DXO Mark.

    Initialization

       

    NULL

    NULL

    NULL

    NULL

    NULL

    XYZoptical to RGB to XYZdata

     

     

    Sr,g,b is the relative spectral transmittance of the filter array not selectivity for XY or Z of a given color.

    Pulling Sr,g,b out of the integral assumes they are scalars. For example Sr attenuates X, Y and Z by the same amount.

    Raw Balance is not White Point Adaptation.

    The transmission loss of Red and Blue pixels relative to green is compensated by D=inverse(S). The relation to incident chromaticity, xy is unchanged as S.D=1.

    (See Bruce Lindbloom; "Spectrum to XYZ" and "RGB/XYZ Matrices" also, Marcel Patek; "Transformation of RGB Primaries")

     

     

    X = (Int(I*xbar*S, lambda))/N:

    Y = (Int(I*ybar*S, lambda))/N:

    Z = (Int(I*zbar*S, lambda))/N:

    N = Int(I*ybar, lambda):

    • 

    XYZ to RGB

    (Vector(3, {(1) = R_Tbb, (2) = G_Tbb, (3) = B_Tbb})) = (Matrix(3, 3, {(1, 1) = XR*Sr, (1, 2) = YR*Sr, (1, 3) = ZR*Sr, (2, 1) = XG*Sg, (2, 2) = YG*Sg, (2, 3) = ZG*Sg, (3, 1) = XB*Sb, (3, 2) = YB*Sb, (3, 3) = ZB*Sb})).(Vector(3, {(1) = X_Tbb, (2) = Y_Tbb, (3) = Z_Tbb}))

    NULL

    (Vector(3, {(1) = R_Tbb, (2) = G_Tbb, (3) = B_Tbb})) = (Matrix(3, 3, {(1, 1) = Sr, (1, 2) = 0, (1, 3) = 0, (2, 1) = 0, (2, 2) = Sg, (2, 3) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = Sb})).(Matrix(3, 3, {(1, 1) = XR, (1, 2) = YR, (1, 3) = ZR, (2, 1) = XG, (2, 2) = YG, (2, 3) = ZG, (3, 1) = XB, (3, 2) = YB, (3, 3) = ZB})).(Vector(3, {(1) = X_Tbb, (2) = Y_Tbb, (3) = Z_Tbb}))

     

    Camera_Neutral = (Matrix(3, 3, {(1, 1) = Sr, (1, 2) = 0, (1, 3) = 0, (2, 1) = 0, (2, 2) = Sg, (2, 3) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = Sb})).(Matrix(3, 3, {(1, 1) = XR, (1, 2) = YR, (1, 3) = ZR, (2, 1) = XG, (2, 2) = YG, (2, 3) = ZG, (3, 1) = XB, (3, 2) = YB, (3, 3) = ZB})).(Vector(3, {(1) = X_wht, (2) = Y_wht, (3) = Z_wht}))

    NULL

    NULL

    NULL

    • 

    RGB to XYZ (The extra step of adaptation to D50 is included below)

     

    (Vector(3, {(1) = X_D50, (2) = Y_D50, (3) = Z_D50})) = (Matrix(3, 3, {(1, 1) = XTbbtoXD50, (1, 2) = YTbbtoXD50, (1, 3) = ZTbbtoXD50, (2, 1) = XTbbtoYD50, (2, 2) = YTbbtoYD50, (2, 3) = ZTbbtoYD50, (3, 1) = XTbbtoZD50, (3, 2) = YTbbtoZD50, (3, 3) = ZTbbtoZD50})).(Matrix(3, 3, {(1, 1) = RX*Dr, (1, 2) = GX*Dg, (1, 3) = BX*Db, (2, 1) = RY*Dr, (2, 2) = GY*Dg, (2, 3) = BY*Db, (3, 1) = RZ*Dr, (3, 2) = GZ*Dg, (3, 3) = BZ*Db})).(Vector(3, {(1) = R_Tbb, (2) = G_Tbb, (3) = B_Tbb})) NULL

    NULL

    (Vector(3, {(1) = X_D50, (2) = Y_D50, (3) = Z_D50})) = (Matrix(3, 3, {(1, 1) = XTbbtoXD50, (1, 2) = YTbbtoXD50, (1, 3) = ZTbbtoXD50, (2, 1) = XTbbtoYD50, (2, 2) = YTbbtoYD50, (2, 3) = ZTbbtoYD50, (3, 1) = XTbbtoZD50, (3, 2) = YTbbtoZD50, (3, 3) = ZTbbtoZD50})).(Matrix(3, 3, {(1, 1) = RX, (1, 2) = GX, (1, 3) = BX, (2, 1) = RY, (2, 2) = GY, (2, 3) = BY, (3, 1) = RZ, (3, 2) = GZ, (3, 3) = BZ})).(Matrix(3, 3, {(1, 1) = Dr, (1, 2) = 0, (1, 3) = 0, (2, 1) = 0, (2, 2) = Dg, (2, 3) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = Db})).(Vector(3, {(1) = R_Tbb, (2) = G_Tbb, (3) = B_Tbb}))

    NULL

    (Vector(3, {(1) = X_D50, (2) = Y_D50, (3) = Z_D50})) = (Matrix(3, 3, {(1, 1) = RX_D50, (1, 2) = GX_D50, (1, 3) = BX_D50, (2, 1) = RY_D50, (2, 2) = GY_D50, (2, 3) = BY_D50, (3, 1) = RZ_D50, (3, 2) = GZ_D50, (3, 3) = BZ_D50})).(Matrix(3, 3, {(1, 1) = Dr, (1, 2) = 0, (1, 3) = 0, (2, 1) = 0, (2, 2) = Dg, (2, 3) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = Db})).(Vector(3, {(1) = R_Tbb, (2) = G_Tbb, (3) = B_Tbb}))

    NULL

    (Vector(3, {(1) = X_D50wht, (2) = Y_D50wht, (3) = Z_D50wht})) = (Matrix(3, 3, {(1, 1) = RX_D50, (1, 2) = GX_D50, (1, 3) = BX_D50, (2, 1) = RY_D50, (2, 2) = GY_D50, (2, 3) = BY_D50, (3, 1) = RZ_D50, (3, 2) = GZ_D50, (3, 3) = BZ_D50})).(Matrix(3, 3, {(1, 1) = Dr, (1, 2) = 0, (1, 3) = 0, (2, 1) = 0, (2, 2) = Dg, (2, 3) = 0, (3, 1) = 0, (3, 2) = 0, (3, 3) = Db})).Camera_Neutral

    NULL

    Functions

       

    NULL

    Input Data

       

    NULL

    Solve for Camera to XYZ D50 and T

       

    NULL

     

     

    For all real a, the partial sums sn= sum((-1)^k (k^(1/k) -a), k=1..n) are bounded so that their limit points form an interval [-1.+  the MRB constant +a, MRB constant] of length 1-a, where the MRB constant is limit(sum((-1)^k*(k^(1/k)), k = 1 ..2*N),N=infinity).

    For all complex z, the upper limit point of  sn= sum((-1)^k (k^(1/k) -z), k=1..n) is the  the MRB constant.

    We see that maple knows the basics of this because when we enter sum((-1)^k*(k^(1/k)-z), k = 1 .. n) 

    maple gives

    sum((-1)^k*(k^(1/k)-z), k = 1 .. n)

     

    marvinrayburns.com

    I am sure that with this vector file with embedded components will learn how it works the vector operations. The code is free and can be modified to be improved. Forward engineers.

     

    Vectores_con_Components_Embedded.mw     (in spanish)      

     

    Lenin Araujo Castillo

    Using MathContainer and Button for 3D vectors.

     

    Angulos_Directores_con_Componentes.mw

    (In spanish)

    https://www.youtube.com/watch?v=J25P_qNtQe8

     

    Aujourd’hui, je suis ravis d’annoncer la disponibilité d’une large banque de questions françaises supportant les enseignements du secondaire et de l’enseignement supérieur. Ce contenu didactique est disponible via le MapleTA Cloud, et également grâce au lien de téléchargement ci-dessous.

    Lien de téléchargement de la banque de questions françaises

    Ces questions sont librement et gratuitement accessibles, et vous pouvez les utiliser directement sur vos propres évaluations et exercices dans MapleTA, ou les éditer et modifier pour les adapter à vos besoins.

    Le contenu de cette banque de questions françaises traite de sujets pour les classes et enseignements pré-bac, post-bac pour en majorité les matières scientifiques.

    Les matières traitées par niveaux et domaines sont:

    Lycées :

    • Electricité
    • Équations Différentielles
    • Gravitation universelle
    • Langues
    • Maths I
    • Maths II
    • Physique
    • Chimie
    • Mécanique

    Enseignement supérieur (Post-Bac) :

    • Astrobiologie
    • Introduction au Calcul pour la Biologie
    • Chimie
    • Déplacement d'onde
    • Electricité & Magnétisme
    • Maths pour l’économie
    • Maths Post-Bac
    • Mécanique Angulaire
    • Mécanique des Fluides
    • Mécanique linéaire
    • Physique Post-Bac
    • Electrocinétique
    • Matériau
    • Mécanique des Fluides
    • Thermodynamique

    Jonny Zivku
    Maplesoft Product Manager, Maple T.A.

    Several Maple T.A. users have developed comprehensive sets of question content and assignments to support full courses in Maple T.A. These questions are available through the Maple T.A. Cloud, and we have decided to also post the associated course modules on Maple Primes as an alternative way of accessing this content.

    Below you will find a link to the Introductory Calculus Maple T.A.. course module developed by Keele University.

    This testing content is freely distributed, and can be used in your own Maple T.A. tests either as-is, or with edits.

    These questions are designed to accompany the first semester of an introductory honours calculus course. The course is intended primarily for students who need or expect to pursue further studies in mathematics, physics, chemistry, engineering and computer science. With over 250 question, topics include: basic material about functions, polynomials, logs and exponentials, the concept of the derivative, and lots of practise exercises for finding derivatives and integrals, and material about series.

    Jonny Zivku
    Maplesoft Product Manager, Maple T.A.

    Several Maple T.A. users have developed comprehensive sets of question content and assignments to support full courses in Maple T.A. These questions are available through the Maple T.A. Cloud, and we have decided to also post the associated course modules on Maple Primes as an alternative way of accessing this content.

    Below you will find a link to the Introductory Calculus for Biological Sciences Maple T.A.. course module developed by the University of Guelph.

    This testing content is freely distributed, and can be used in your own Maple T.A. tests either as-is, or with edits.

    The Introductory Calculus for Biological Sciences course module is designed to cover a single-semester introductory calculus course for biological sciences students at the first-year university level. The questions are designed to span the topics listed below, allowing for practice, homework or testing throughout the semester.

    Topics include:

    • Introduction to Functions
    • Composite and Inverse Functions
    • Trigonometric Functions
    • Logarithms and Exponents
    • Sequences and Finite Series
    • Limits and Continuity
    • Derivatives
    • Curve Sketching
    • Differentials
    • Linear Approximation
    • Taylor Polynomials
    • Difference Equations
    • Log-Log Graphs
    • Anti-Differentiation
    • Definite Integrals

    Jonny Zivku
    Maplesoft Product Manager, Maple T.A.

    First 72 73 74 75 76 77 78 Last Page 74 of 296