Introduction
Dating back to European traditions, Halloween originated from the ancient Gaelic festival, Samhain. It was a day to celebrate the end of the harvest season – it means “summer's end”. It is thought that the Pagan Samhain was Christianised into Halloween by the early Christian church, and modern day customs have their roots in early folklore, Pagan beliefs and early Christianity. The word Halloween itself is a Scottish term for All Hallows Eve - basically, the evening before All Saints' Day. Historically Gaels thought the walls between the spiritual realm and our world were thin. In order to protect their crops, they would set up places at their dinner tables for good spirits and light bonfires to scare off evil spirits. Trick or treating and dressing up came from 16th Century Ireland, Scotland and Wales. People would ask for food in exchange for a poem or song. People dressed up in scary costumes and impersonated the souls of the dead to protect themselves.


{% extends 'courses/preview.html' %} {% load url from future %} {% block course_description %}
This is an introductory course on computer networking, specifically the Internet. It focuses on explaining how the Internet works, ranging from how bits are modulated on wires and in wireless to application-level protocols like BitTorrent and HTTP. It also explains the principles of how to design networks and network protocols. Students gain experience reading and understanding RFCs (Internet protocol specifications) as statements of what a system should do. The course grounds many of the concepts in current practice and recent developments, such as net neutrality and DNS security.
Nick McKeown has been a Professor of Electrical Engineering and Computer Science at Stanford University since 1995. He grew up in the UK and received his BEng from Leeds University in 1986. He moved to the US in 1989 to do an MS and PhD in Electrical Engineering and Computer Science at University of California at Berkeley. His research group works on new Internet architectures, software-defined networks and how to make routers faster. He co-founded several companies based on technology started at Stanford. He is a member of the National Academy of Engineering and recently received the ACM Sigcomm "Lifetime Achievement" Award.
Philip Levis is an Associate Professor of Computer Science and Electrical Engineering at Stanford University. He received his Sc.B. from Brown University in 1999, his M.S. from the University of Colorado at Boulder in 2001, and his Ph.D. from UC Berkeley in 2005. In 2008 he received an NSF CAREER award and a Microsoft Research New Faculty Fellowship. He researches the design and implementation of networked systems, including operating systems and protocols for embedded wireless devices, wireless mesh protocols, network infrastructure for virtual worlds, and energy efficient computing. The results of his research, including the TinyOS operating system, nesC language, Trickle algorithm, and the collection tree protocol (CTP), have been adopted by tens of thousands of users and researchers worldwide. He is a co-founder and the President of Kumu Networks. He really likes excellent engineering and has a self-destructive aversion to low-hanging fruit.
Students need an introductory course in probability, a strong understanding of bits and bytes, and knowledge of how computers lay out data in memory.


|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Interface Summary | |
|---|---|
| ICONSTANT_Methodref_info | A CONSTANT_Methodref_info or CONSTANT_InterfaceMethodref_info . |
| Interface_Astore | |
| Interface_OneIntArg |
| Class Summary | |
|---|---|
| annotation | There can be many annotations in each Visibility attribute |
| annotation_element_value | There can be many element_value pairs in each annotation |
| AnnotationDefault_attribute | There should be at most one AnnotationDefault attribute in every method indicating the default value of the element represented by the method_info structure |
| array_element_value | There can be many element_value pairs in each annotation |
| CFG | A Control Flow Graph. |
| class_element_value | There can be many element_value pairs in each annotation |
| ClassFile | A ClassFile object represents the contents of a .class file. |
| CoffiMethodSource | |
| CONSTANT_Class_info | A constant pool entry of type CONSTANT_Class. |
| constant_element_value | There can be many element_value pairs in each annotation |
| CONSTANT_Utf8_collector | Provides sharing for Utf8_info string objects reused in different contexts. |
| CONSTANT_Utf8_info | A constant pool entry of type CONSTANT_Utf8; note this is not multithread safe. |
| Double2ndHalfType | |
| element_value | There can be many element_value pairs in each annotation |
| enum_constant_element_value | There can be many element_value pairs in each annotation |
| Exception_attribute | There should be exactly one Exceptions attribute in every method, indicating the types of exceptions the method might throw. |
| field_info | Represents a single field_info object. |
| LineNumberTable_attribute | A debugging attribute, this associates blocks of bytecode with specific source code line numbers. |
| Long2ndHalfType | |
| method_info | Represents a single method_info object. |
| parameter_annotation | There can be several parameter annotations in each Parameter Visibility attribute |
| RuntimeInvisibleAnnotations_attribute | There should be at most one RuntimeInvisibleAnnotations attribute in every method, field and class indicating the list of annotations. |
| RuntimeInvisibleParameterAnnotations_attribute | There should be at most one RuntimeVisibleParameterAnnotations attribute in method indicating the list of annotations for each method parameter |
| RuntimeVisibleAnnotations_attribute | There should be at most one RuntimeVisibleAnnotations attribute in every method, field and class indicating the list of annotations. |
| RuntimeVisibleParameterAnnotations_attribute | There should be at most one RuntimeVisibleParameterAnnotations attribute in method indicating the list of annotations for each method parameter |
| SourceFile_attribute | A debugging attribute, this gives the name of the source file for this .class file. |
| UnusuableType | |
| Utf8_Enumeration | An enumeration of a Utf8 allows one to run through the characters in a unicode string; used primarily for comparing unicode strings. |
| Util |
Contains classes from the Coffi tool, by Clark Verbrugge. They are used by Soot to parse classfiles. (Note that Baf is currently used only for output from Soot; conceivably, Coffi could create Baf bodies, but it doesn't.)
|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


[gecode-users] Performance Issue of Gecode
Jeffrey
jeffreym9 at yahoo.com.hk
Tue Mar 31 20:23:55 CEST 2009
Dear all,
I have written a problem with a IntVarArray of size 49 for branching.
Each IntVar is in domain {0-2}
There are 30 something constraints. It turns out to run around 1 hour.
Is that a normal performance?
Is there any way I can optimize my program?
Any pointer for me in how to optimize my program?
Yahoo!香港提供網上安全攻略，教你如何防範黑客! 請前往 http://hk.promo.yahoo.com/security/ 了解更多!
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.ps.uni-sb.de/pipermail/users/attachments/20090331/dc3e408c/attachment.htm>
More information about the gecode-users
mailing list


You can save your current working project by selecting Save or Save As command from File Menu or Save command from File Toolbar
If saving was successful you will get following message:


If the match is completed
If the match has been initialized and checks have been passed, the match is ready to run using Match.run
If the match is running at the moment
If the match is stopped
Match was created with new but initialize was not called
Generated using TypeDoc
If fatal error occurs in Match, appears when match stops itself


Mordred, The Dark Knight:
Ha! A worm like you could never understand my teachings!
Leave now and I'll let you live!


Preparation time
less than 30 mins
Cooking time
30 mins to 1 hour
Serves
Serves 4
Tasty poached chicken with a herby tomato and garlic dressing is served with a simple-to-make potato salad. Serve with pesto or sun-dried tomato bread for a summer weekend lunch party.
Heat the stock in a deep frying pan and gently poach the chicken for 10-15 minutes. Place in a bowl.
While the chicken is cooking, put the shallots, garlic and herbs into a blender and pulse until finely chopped.
Add the tomato ketchup and slowly incorporate the oil, lemon juice and Worcestershire sauce. Blend until combined and season to taste.
Pour the tomato and tarragon dressing over the chicken, leave to cool and marinate.
Bring a large pan of salted water to the boil. Cook the new potatoes until tender. Drain and chill.
Bring a large pan of salted water to the boil. Blanch the asparagus for 2-3 minutes. Drain and chill.
Chop the shallots, dice the new potatoes and add the asparagus and snipped chives.
Gently fold in the mayonnaise, season to taste and refrigerate.
Remove the chicken from the dressing and put on a large serving plate or bowl. Pour over the dressing and spoon the potato and asparagus salad on to the plate.
Finish with fried vine cherry tomatoes and basil leaves and serve.


Scotland Women suffer narrow defeat against Japan at Scotstoun
by By Online EditorsMegan Gaffney scored two tries as Scotland suffered a last-gasp 24-20 defeat to Japan at Scotstoun.
Gaffney opened the scoring in the second minute and grabbed her second try in the 56th minute before Rachel Malcolm powered over from a rolling maul to put Scotland 20-10 in front.
However, Makoto Ebuchi’s try in the 71st minute was converted by Ai Hirayama to reduce the deficit and substitute Ayasa Otsuka glided over in the 79th minute to seal victory for the visitors, with Hirayama converting from in front of the posts.
The Season 5 – Episode 3
A changing room reminder about team values and expectations encourages the squad to train with consistency but mistakes start to creep in.


This is a small LSTM recurrent neural network that generates a bug name character by character. It's a retrained, thinly reskinned version of Autoglot. Just like Autoglot, bugtime's model was trained with this tool by this person. Learn about the technique from Andrej Karpathy.


Before Change
hass.states.set(entity_id, "state{}".format(idx), attributes)
hass.block_till_done()
recorder._INSTANCE.block_till_done()
db_states = recorder.query("States")
states = recorder.execute(db_states)
assert db_states[0].event_id is not None
return states
After Change
hass.data[DATA_INSTANCE].block_till_done()
with session_scope(hass=hass) as session:
return [st.to_native() for st in session.query(States)]
// pylint: disable=redefined-outer-name,invalid-name
def test_saving_state_include_domains(hass_recorder):


|
ReactPhysics3D
0.6.0
Physics engine library
|
This abstract class represents a joint between two bodies. More...
#include <Joint.h>
Public Member Functions | |
| Joint (const JointInfo &jointInfo) | |
| Constructor. | |
| virtual | ~Joint () |
| Destructor. | |
| RigidBody * | getBody1 () const |
| Return the reference to the body 1. More... | |
| RigidBody * | getBody2 () const |
| Return the reference to the body 2. More... | |
| bool | isActive () const |
| Return true if the constraint is active. More... | |
| JointType | getType () const |
| Return the type of the constraint. More... | |
| bool | isCollisionEnabled () const |
| Return true if the collision between the two bodies of the joint is enabled. More... | |
Protected Member Functions | |
| Joint (const Joint &constraint) | |
| Private copy-constructor. | |
| Joint & | operator= (const Joint &constraint) |
| Private assignment operator. | |
| bool | isAlreadyInIsland () const |
| Return true if the joint has already been added into an island. | |
| virtual size_t | getSizeInBytes () const =0 |
| Return the number of bytes used by the joint. | |
| virtual void | initBeforeSolve (const ConstraintSolverData &constraintSolverData)=0 |
| Initialize before solving the joint. | |
| virtual void | warmstart (const ConstraintSolverData &constraintSolverData)=0 |
| Warm start the joint (apply the previous impulse at the beginning of the step) | |
| virtual void | solveVelocityConstraint (const ConstraintSolverData &constraintSolverData)=0 |
| Solve the velocity constraint. | |
| virtual void | solvePositionConstraint (const ConstraintSolverData &constraintSolverData)=0 |
| Solve the position constraint. | |
Protected Attributes | |
| RigidBody *const | mBody1 |
| Pointer to the first body of the joint. | |
| RigidBody *const | mBody2 |
| Pointer to the second body of the joint. | |
| const JointType | mType |
| Type of the joint. | |
| uint | mIndexBody1 |
| Body 1 index in the velocity array to solve the constraint. | |
| uint | mIndexBody2 |
| Body 2 index in the velocity array to solve the constraint. | |
| JointsPositionCorrectionTechnique | mPositionCorrectionTechnique |
| Position correction technique used for the constraint (used for joints) | |
| bool | mIsCollisionEnabled |
| True if the two bodies of the constraint are allowed to collide with each other. | |
| bool | mIsAlreadyInIsland |
| True if the joint has already been added into an island. | |
Friends | |
| class | DynamicsWorld |
| class | Island |
| class | ConstraintSolver |
This abstract class represents a joint between two bodies.
|
inline |
Return the reference to the body 1.
|
inline |
Return the reference to the body 2.
|
inline |
Return the type of the constraint.
|
inline |
Return true if the constraint is active.
|
inline |
Return true if the collision between the two bodies of the joint is enabled.


BSC_Computer Science
GOVT VICTORIA COLLEGE PALAKKAD
Departement of Computer Science was started in the year 2012 in our College. It aims at providing basic Computer Skills to the Students.
Our Faculties
- Sajeev Krishnan M A
- Swapna M P
- Prajitha P
- Sumithra C
FACILITIES
LIBRARY
Our library has enough reference materials to provide additional information to students and teachers. Students can utilize the library facility during the lunch break and free hours.
LAB
We have well furnished computer lab with modern equipped terminals and loaded with high-end softwares pertaining to the curriculum.Labs are fully air conditioned with power backup facility and professionally set.
wifi Enabled
We provide high speed WIFI connection for educational purposes to staff and students.
Smart Class
We provide well furnished class rooms having modern teaching aids,tutorial room and multimedia facilities.Our class rooms are most modern and include features such as network connectivity a white board for presentations,dustless chalk etc...


Our Story
DeadPlanets Mission
Which One Are You?
"I'm Batman"-Isaac Hall/2019
How do you feel about climate change? Well then ask yourself how willing are you to help stop it.
Use this section to determine what is the best choice for you to help stop the climate change horror. If you use our website
you will be able to determine how environmentally friendly you are. By looking in this section you are faced with different
guidelines by doing the easy you care for the environment but cant do much to help, if you choose the medium section you are
willing to change your lifestyle to help your environment and if you choose the hard you are willing to stop what you want
and only care for your environment.
Plan
Choose a plan that suits you.
- Easy
- Pickup Litter and Rubbish in Your Town
- Call on Your Local Council to Make Change
- Recycle More In Your House
- Walk To Work/School
-
Cost: Free
-
- Medium
- Reduce The Amount You Watch TV
- Stop Unnecesary Travel
- Buy New Devices When You Need To
- Donate To Support Groups
-
Cost: Just A Little Bit
-
- Hard
- Buy An Electric Car
- Protest For Change
- Get Solar Panels
- Invest and Donate In Climate Change Companies
-
Cost: A Change For Good
-


|
spGpu library
1.2.3
spgpu
|
Functions | |
| int | computeBcooSize (int blockRows, int blockCols, const int *rows, const int *cols, int nonZeros) |
| void | cooToBcoo (int *bRows, int *bCols, void *blockValues, int blockRows, int blockCols, const int *rows, const int *cols, const void *values, int nonZeros, spgpuType_t valuesType) |
| int | computeDiaDiagonalsCount (int rowsCount, int columnsCount, int nonZerosCount, const int *cooRowIndices, const int *cooColsIndices) |
| void | coo2dia (void *values, int *offsets, int valuesPitch, int diagonals, int rowsCount, int columnsCount, int nonZerosCount, const int *cooRowIndices, const int *cooColsIndices, const void *cooValues, int cooBaseIndex, spgpuType_t valuesType) |
| int | computeDiaAllocPitch (int rowsCount) |
| void | computeEllRowLenghts (int *ellRowLengths, int *ellMaxRowSize, int rowsCount, int nonZerosCount, const int *cooRowIndices, int cooBaseIndex) |
| int | computeEllAllocPitch (int rowsCount) |
| void | cooToEll (void *ellValues, int *ellIndices, int ellValuesPitch, int ellIndicesPitch, int ellMaxRowSize, int ellBaseIndex, int rowsCount, int nonZerosCount, const int *cooRowIndices, const int *cooColsIndices, const void *cooValues, int cooBaseIndex, spgpuType_t valuesType) |
| void | ellToOell (int *rIdx, void *dstEllValues, int *dstEllIndices, int *dstRs, const void *srcEllValues, const int *srcEllIndices, const int *srcRs, int ellValuesPitch, int ellIndicesPitch, int rowsCount, spgpuType_t valuesType) |
| int | getHdiaHacksCount (int hackSize, int rowsCount) |
| void | computeHdiaHackOffsets (int *allocationHeight, int *hackOffsets, int hackSize, const void *diaValues, int diaValuesPitch, int diagonals, int rowsCount, spgpuType_t valuesType) |
| void | diaToHdia (void *hdiaValues, int *hdiaOffsets, const int *hackOffsets, int hackSize, const void *diaValues, const int *diaOffsets, int diaValuesPitch, int diagonals, int rowsCount, spgpuType_t valuesType) |
| void | computeHdiaHackOffsetsFromCoo (int *allocationHeight, int *hackOffsets, int hackSize, int rowsCount, int columnsCount, int nonZerosCount, const int *cooRowIndices, const int *cooColsIndices, int cooBaseIndex) |
| void | cooToHdia (void *hdiaValues, int *hdiaOffsets, const int *hackOffsets, int hackSize, int rowsCount, int columnsCount, int nonZerosCount, const int *cooRowIndices, const int *cooColsIndices, const void *cooValues, int cooBaseIndex, spgpuType_t valuesType) |
| void | bcooToBhdia (void *hdiaValues, int *hdiaOffsets, const int *hackOffsets, int hackSize, int rowsCount, int columnsCount, int nonZerosCount, const int *cooRowIndices, const int *cooColsIndices, const void *cooValues, int cooBaseIndex, spgpuType_t valuesType, int blockSize) |
| void | computeHellAllocSize (int *allocationHeight, int hackSize, int rowsCount, const int *ellRowLengths) |
| void | ellToHell (void *hellValues, int *hellIndices, int *hackOffsets, int hackSize, const void *ellValues, const int *ellIndices, int ellValuesPitch, int ellIndicesPitch, int *ellRowLengths, int rowsCount, spgpuType_t valuesType) |
| void bcooToBhdia | ( | void * | hdiaValues, |
| int * | hdiaOffsets, | ||
| const int * | hackOffsets, | ||
| int | hackSize, | ||
| int | rowsCount, | ||
| int | columnsCount, | ||
| int | nonZerosCount, | ||
| const int * | cooRowIndices, | ||
| const int * | cooColsIndices, | ||
| const void * | cooValues, | ||
| int | cooBaseIndex, | ||
| spgpuType_t | valuesType, | ||
| int | blockSize | ||
| ) |
| int computeBcooSize | ( | int | blockRows, |
| int | blockCols, | ||
| const int * | rows, | ||
| const int * | cols, | ||
| int | nonZeros | ||
| ) |
| int computeDiaAllocPitch | ( | int | rowsCount | ) |
This function returns a pitch (in number of elements) that can be used to allocate the values array for DIA matrix format.
| rowsCount | the rows count |
| int computeDiaDiagonalsCount | ( | int | rowsCount, |
| int | columnsCount, | ||
| int | nonZerosCount, | ||
| const int * | cooRowIndices, | ||
| const int * | cooColsIndices | ||
| ) |
| int computeEllAllocPitch | ( | int | rowsCount | ) |
This function returns a pitch (in number of elements) that can be used to allocate both indices and values arrays for ELL matrix format.
| rowsCount | the rows count |
| void computeEllRowLenghts | ( | int * | ellRowLengths, |
| int * | ellMaxRowSize, | ||
| int | rowsCount, | ||
| int | nonZerosCount, | ||
| const int * | cooRowIndices, | ||
| int | cooBaseIndex | ||
| ) |
Compute the Ell row lengths array (and the greatest row size) from the COO matrix format.
| ellRowLengths | Array of length rowsCount to be filled by the non zeros count for every matrix row |
| ellMaxRowSize | outputs the greatest row size (in non zeros) |
| rowsCount | the number of rows of the coo matrix to convert |
| nonZerosCount | the non zeros count of the coo matrix to convert |
| cooRowIndices | the row indices array for the coo matrix to convert |
| cooBaseIndex | the input base index (e.g. 0 for C, 1 for Fortran) |
| void computeHdiaHackOffsets | ( | int * | allocationHeight, |
| int * | hackOffsets, | ||
| int | hackSize, | ||
| const void * | diaValues, | ||
| int | diaValuesPitch, | ||
| int | diagonals, | ||
| int | rowsCount, | ||
| spgpuType_t | valuesType | ||
| ) |
| void computeHdiaHackOffsetsFromCoo | ( | int * | allocationHeight, |
| int * | hackOffsets, | ||
| int | hackSize, | ||
| int | rowsCount, | ||
| int | columnsCount, | ||
| int | nonZerosCount, | ||
| const int * | cooRowIndices, | ||
| const int * | cooColsIndices, | ||
| int | cooBaseIndex | ||
| ) |
| void computeHellAllocSize | ( | int * | allocationHeight, |
| int | hackSize, | ||
| int | rowsCount, | ||
| const int * | ellRowLengths | ||
| ) |
Compute the HELL format allocation's height for the Hell allocation (the resulting size should be allocationHeight*hackSize*sizeof(elementsType)).
| allocationHeight | outputs the total allocation's height |
| hackSize | the hack size for this matrix (32 or 64 are good choices) |
| rowsCount | the rows count |
| ellRowLengths | the row lengths array from the ell matrix to convert |
| void coo2dia | ( | void * | values, |
| int * | offsets, | ||
| int | valuesPitch, | ||
| int | diagonals, | ||
| int | rowsCount, | ||
| int | columnsCount, | ||
| int | nonZerosCount, | ||
| const int * | cooRowIndices, | ||
| const int * | cooColsIndices, | ||
| const void * | cooValues, | ||
| int | cooBaseIndex, | ||
| spgpuType_t | valuesType | ||
| ) |
| void cooToBcoo | ( | int * | bRows, |
| int * | bCols, | ||
| void * | blockValues, | ||
| int | blockRows, | ||
| int | blockCols, | ||
| const int * | rows, | ||
| const int * | cols, | ||
| const void * | values, | ||
| int | nonZeros, | ||
| spgpuType_t | valuesType | ||
| ) |
| void cooToEll | ( | void * | ellValues, |
| int * | ellIndices, | ||
| int | ellValuesPitch, | ||
| int | ellIndicesPitch, | ||
| int | ellMaxRowSize, | ||
| int | ellBaseIndex, | ||
| int | rowsCount, | ||
| int | nonZerosCount, | ||
| const int * | cooRowIndices, | ||
| const int * | cooColsIndices, | ||
| const void * | cooValues, | ||
| int | cooBaseIndex, | ||
| spgpuType_t | valuesType | ||
| ) |
Convert a matrix in COO format to a matrix in ELL format. The matrix is stored in column-major format. The ellValues and ellIndices sizes are ellMaxRowSize * pitch (pitch is in bytes).
| ellValues | pointer to the area that will be filled by the non zero coefficients |
| ellIndices | pointer to the area that will be filled by the non zero indices |
| ellValuesPitch | the column-major allocation's pitch of ellValues (in number of elements) |
| ellIndicesPitch | the column-major allocation's pitch of ellIndices (in number of elements) |
| ellMaxRowSize | the greatest row size |
| ellBaseIndex | the desired base index for the ELL matrix (e.g. 0 for C, 1 for Fortran) |
| rowsCount | input matrix rows count |
| nonZerosCount | input matrix non zeros count |
| cooRowIndices | input matrix row indices pointer |
| cooColsIndices | input matrix column indices pointer |
| cooValues | input matrix non zeros values pointer |
| cooBaseIndex | input matrix base index |
| valuesType | the type for elements in ellValues and cooValues (i.e. SPGPU_TYPE_FLOAT or SPGPU_TYPE_DOUBLE) |
| void cooToHdia | ( | void * | hdiaValues, |
| int * | hdiaOffsets, | ||
| const int * | hackOffsets, | ||
| int | hackSize, | ||
| int | rowsCount, | ||
| int | columnsCount, | ||
| int | nonZerosCount, | ||
| const int * | cooRowIndices, | ||
| const int * | cooColsIndices, | ||
| const void * | cooValues, | ||
| int | cooBaseIndex, | ||
| spgpuType_t | valuesType | ||
| ) |
| void diaToHdia | ( | void * | hdiaValues, |
| int * | hdiaOffsets, | ||
| const int * | hackOffsets, | ||
| int | hackSize, | ||
| const void * | diaValues, | ||
| const int * | diaOffsets, | ||
| int | diaValuesPitch, | ||
| int | diagonals, | ||
| int | rowsCount, | ||
| spgpuType_t | valuesType | ||
| ) |
| void ellToHell | ( | void * | hellValues, |
| int * | hellIndices, | ||
| int * | hackOffsets, | ||
| int | hackSize, | ||
| const void * | ellValues, | ||
| const int * | ellIndices, | ||
| int | ellValuesPitch, | ||
| int | ellIndicesPitch, | ||
| int * | ellRowLengths, | ||
| int | rowsCount, | ||
| spgpuType_t | valuesType | ||
| ) |
Convert a matrix from the ELL format to the HELL format.
| hellValues | pointer to the area that will be filled by the non zero coefficients |
| hellIndices | pointer to the area that will be filled by the non zero indices |
| hackOffsets | |
| hackSize | the hack size used to allocate hellValues and hellIndices (32 or 64 are good choices) |
| ellValues | the input matrix coefficients |
| ellIndices | the input matrix indices |
| ellValuesPitch | the input values allocation pitch (in number of elements) |
| ellIndicesPitch | the input indices allocation pitch (in number of elements) |
| ellRowLengths | the row lengths array of the input matrix |
| rowsCount | the rows count |
| valuesType | the type of hellValues and ellValues elements (i.e. SPGPU_TYPE_FLOAT or SPGPU_TYPE_DOUBLE) |
| void ellToOell | ( | int * | rIdx, |
| void * | dstEllValues, | ||
| int * | dstEllIndices, | ||
| int * | dstRs, | ||
| const void * | srcEllValues, | ||
| const int * | srcEllIndices, | ||
| const int * | srcRs, | ||
| int | ellValuesPitch, | ||
| int | ellIndicesPitch, | ||
| int | rowsCount, | ||
| spgpuType_t | valuesType | ||
| ) |
| int getHdiaHacksCount | ( | int | hackSize, |
| int | rowsCount | ||
| ) |